@orderly.network/hooks 2.0.7 → 2.1.0

package/dist/index.js

@@ -3,12 +3,14 @@
 var useSWR = require('swr');
 var net = require('@orderly.network/net');
 var React = require('react');
+var types = require('@orderly.network/types');
 var useSWRMutation = require('swr/mutation');
 var useConstant = require('use-constant');
 var core = require('@orderly.network/core');
 var utils = require('@orderly.network/utils');
-var types = require('@orderly.network/types');
+var lodash = require('lodash');
 var useSWRInfinite = require('swr/infinite');
+var amplitude = require('@amplitude/analytics-browser');
 var jsxRuntime = require('react/jsx-runtime');
 var ramda = require('ramda');
 var zustand = require('zustand');
@@ -20,7 +22,6 @@ var immer$1 = require('immer');
 var defaultEvmAdapter = require('@orderly.network/default-evm-adapter');
 var defaultSolanaAdapter = require('@orderly.network/default-solana-adapter');
 var web3ProviderEthers = require('@orderly.network/web3-provider-ethers');
-var amplitude = require('@amplitude/analytics-browser');
 var qr = require('@akamfoad/qr');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -48,8 +49,8 @@ var React__default = /*#__PURE__*/_interopDefault(React);
 var useSWRMutation__default = /*#__PURE__*/_interopDefault(useSWRMutation);
 var useConstant__default = /*#__PURE__*/_interopDefault(useConstant);
 var useSWRInfinite__default = /*#__PURE__*/_interopDefault(useSWRInfinite);
-var useSWRSubscription__default = /*#__PURE__*/_interopDefault(useSWRSubscription);
 var amplitude__namespace = /*#__PURE__*/_interopNamespace(amplitude);
+var useSWRSubscription__default = /*#__PURE__*/_interopDefault(useSWRSubscription);
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -60,20 +61,18 @@ var __export = (target, all) => {
 // src/version.ts
 if (typeof window !== "undefined") {
   window.__ORDERLY_VERSION__ = window.__ORDERLY_VERSION__ || {};
-  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.0.7";
+  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.1.0";
 }
-var version_default = "2.0.7";
+var version_default = "2.1.0";
 var fetcher = (url, init2 = {}, queryOptions) => net.get(url, init2, queryOptions?.formatter);
 var OrderlyContext = React.createContext({
   // configStore: new MemoryConfigStore(),
 });
 var OrderlyProvider = OrderlyContext.Provider;
-
-// src/useConfig.ts
 function useConfig(key, defaultValue) {
   const { configStore } = React.useContext(OrderlyContext);
   if (!configStore) {
-    throw new Error(
+    throw new types.SDKError(
       "useConfig must be used within OrderlyConfigProvider or OrderlyAppProvider"
     );
   }
@@ -85,13 +84,11 @@ function useConfig(key, defaultValue) {
   }
   return configStore;
 }
-
-// src/useQuery.ts
 var useQuery = (query, options) => {
   const apiBaseUrl = useConfig("apiBaseUrl");
   const { formatter, ...swrOptions } = options || {};
   if (typeof apiBaseUrl === "undefined") {
-    throw new Error("please add OrderlyConfigProvider to your app");
+    throw new types.SDKError("please add OrderlyConfigProvider to your app");
   }
   return useSWR__default.default(
     query,
@@ -105,7 +102,7 @@ var useLazyQuery = (query, options) => {
   const apiBaseUrl = useConfig("apiBaseUrl");
   const { formatter, init: init2, ...swrOptions } = options || {};
   if (typeof apiBaseUrl === "undefined") {
-    throw new Error("please add OrderlyConfigProvider to your app");
+    throw new types.SDKError("please add OrderlyConfigProvider to your app");
   }
   return useSWRMutation__default.default(
     query,
@@ -127,9 +124,11 @@ var useLazyQuery = (query, options) => {
 var useAccountInstance = () => {
   const { configStore, keyStore, walletAdapters } = React.useContext(OrderlyContext);
   if (!configStore)
-    throw new Error("configStore is not defined, please use OrderlyProvider");
+    throw new types.SDKError(
+      "configStore is not defined, please use OrderlyProvider"
+    );
   if (!keyStore) {
-    throw new Error(
+    throw new types.SDKError(
       "keyStore is not defined, please use OrderlyProvider and provide keyStore"
     );
   }
@@ -250,6 +249,26 @@ var useEventEmitter = () => {
     return ee;
   });
 };
+
+// src/useTrack.ts
+var useTrack = () => {
+  const ee = useEventEmitter();
+  const debouncedTrackFn = React.useCallback(
+    lodash.debounce((eventName, params) => {
+      ee.emit(eventName, params);
+    }, 500),
+    []
+  );
+  const track2 = React.useCallback((eventName, params) => {
+    debouncedTrackFn(eventName, params);
+  }, [debouncedTrackFn]);
+  const setTrackUserId = React.useCallback((userId) => {
+    ee.emit(types.EnumTrackerKeys.trackIdentifyUserId, userId);
+  }, []);
+  return { track: track2, setTrackUserId };
+};
+
+// src/useAccount.ts
 var useAccount = () => {
   const {
     configStore,
@@ -259,21 +278,18 @@ var useAccount = () => {
     // onSetChain,
   } = React.useContext(OrderlyContext);
   if (!configStore)
-    throw new Error("configStore is not defined, please use OrderlyProvider");
+    throw new types.SDKError(
+      "configStore is not defined, please use OrderlyProvider"
+    );
   if (!keyStore) {
-    throw new Error(
+    throw new types.SDKError(
       "keyStore is not defined, please use OrderlyProvider and provide keyStore"
     );
   }
   const account5 = useAccountInstance();
   const [state, setState] = React.useState(account5.stateValue);
-  const ee = useEventEmitter();
+  const { track: track2 } = useTrack();
   const statusChangeHandler = (nextState) => {
-    if (types.AccountStatusEnum.Connected === nextState.status) {
-      ee.emit(types.EnumTrackerKeys.WALLET_CONNECT, {
-        ...nextState
-      });
-    }
     setState(() => nextState);
   };
   React.useEffect(() => {
@@ -284,9 +300,9 @@ var useAccount = () => {
   }, []);
   const createOrderlyKey = React.useCallback(
     async (remember) => {
-      ee.emit(types.EnumTrackerKeys.SIGNIN_SUCCESS, {
-        ...state,
-        ...account5
+      track2(types.EnumTrackerKeys.signinSuccess, {
+        network: account5.chainId,
+        wallet: state.connectWallet?.name
       });
       return account5.createOrderlyKey(remember ? 365 : 30);
     },
@@ -511,6 +527,77 @@ var useNetworkInfo = (networkId) => {
     };
   };
 };
+var apiKeyMap = {
+  dev: "4d6b7db0fdd6e9de2b6a270414fd51e0",
+  qa: "96476b00bc2701360f9b480629ae5263",
+  staging: "dffc00e003479b86d410c448e00f2304",
+  prod: "3ab9ae56ed16cc57bc2ac97ffc1098c2"
+};
+var AmplitudeTracker = class {
+  constructor(env, sdkInfo) {
+    this._ee = core.SimpleDI.get("EE");
+    amplitude__namespace.init(apiKeyMap[env], { serverZone: "EU" });
+    this.setSdkInfo(sdkInfo);
+    this._bindEvents();
+  }
+  setUserId(userId) {
+    if (userId === this._userId) {
+      return;
+    }
+    amplitude__namespace.setUserId(userId);
+    this._userId = userId;
+  }
+  setSdkInfo(sdkInfo) {
+    if (this._sdkInfoTag && sdkInfo.address === this._sdkInfoTag)
+      return;
+    const identify2 = new amplitude__namespace.Identify();
+    Object.entries(sdkInfo).forEach(([key, value]) => {
+      identify2.set(key, value);
+    });
+    amplitude__namespace.identify(identify2);
+    this._sdkInfoTag = sdkInfo.address;
+  }
+  identify(identifyEvent) {
+    amplitude__namespace.identify(identifyEvent);
+  }
+  track(eventName, properties) {
+    amplitude__namespace.track(types.TrackerListenerKeyMap[eventName], properties);
+  }
+  _bindEvents() {
+    const listenKeys = Object.keys(types.TrackerListenerKeyMap);
+    listenKeys.forEach((key) => {
+      this._ee.addListener(key, (params = {}) => {
+        if (key === types.EnumTrackerKeys.trackIdentifyUserId) {
+          this.setUserId(params);
+        } else {
+          this.track(key, params);
+        }
+      });
+    });
+  }
+};
+AmplitudeTracker.instanceName = "amplitudeTracker";
+
+// src/useTrackInstance.ts
+var useTrackingInstance = () => {
+  const { configStore } = React.useContext(OrderlyContext);
+  if (!configStore)
+    throw new Error("configStore is not defined, please use OrderlyProvider");
+  const env = configStore.get("env");
+  const brokerId = configStore.get("brokerId");
+  const trackInstace = useConstant__default.default(() => {
+    let instance = core.SimpleDI.get("amplitudeTracker");
+    if (!instance) {
+      instance = new AmplitudeTracker(env, {
+        brokerId,
+        sdk_version: window?.__ORDERLY_VERSION__?.["@orderly.network/net"] ?? ""
+      });
+      core.SimpleDI.registerByName("instance", instance);
+    }
+    return instance;
+  });
+  return trackInstace;
+};
 var WS_NAME = "nativeWebsocketClient";
 var useWS = () => {
   const { configStore } = React.useContext(OrderlyContext);
@@ -794,7 +881,7 @@ var AlgoOrderMergeHandler = class _AlgoOrderMergeHandler extends BaseMergeHandle
       (order) => order.parentAlgoOrderId === 0 && order.algoOrderId === order.rootAlgoOrderId
     );
     if (rootOrderIndex === -1) {
-      throw new Error("Root order not found");
+      throw new types.SDKError("Root order not found");
     }
     const rootOrder_ = object2underscore(
       orders[rootOrderIndex]
@@ -816,7 +903,7 @@ var AlgoOrderMergeHandler = class _AlgoOrderMergeHandler extends BaseMergeHandle
       (order) => order.algoType !== types.AlgoOrderType.STOP_LOSS && order.algoType !== types.AlgoOrderType.TAKE_PROFIT
     );
     if (rootOrderIndex === -1) {
-      throw new Error("Root order not found");
+      throw new types.SDKError("Root order not found");
     }
     const rootOrder = innerOrders.splice(
       rootOrderIndex,
@@ -1886,7 +1973,7 @@ var useFutures = () => {
 // src/orderly/useTickerStream.ts
 var useTickerStream = (symbol) => {
   if (!symbol) {
-    throw new Error("useFuturesForSymbol requires a symbol");
+    throw new types.SDKError("Symbol is required");
   }
   const { data: info } = useQuery(
     `/v1/public/futures/${symbol}`,
@@ -2185,10 +2272,12 @@ var reduceOrderbook = (depth, level, padding, data) => {
 var INIT_DATA = { asks: [], bids: [] };
 var useOrderbookStream = (symbol, initial = INIT_DATA, options) => {
   if (!symbol) {
-    throw new types.SDKError("useOrderbookStream requires a symbol");
+    throw new types.SDKError("Symbol is required");
   }
   const level = options?.level ?? 10;
   const padding = options?.padding ?? true;
+  const symbolRef = React.useRef(symbol);
+  symbolRef.current = symbol;
   const [requestData, setRequestData] = React.useState(null);
   const [data, setData] = React.useState(initial);
   const [isLoading, setIsLoading] = React.useState(true);
@@ -2231,13 +2320,17 @@ var useOrderbookStream = (symbol, initial = INIT_DATA, options) => {
         formatter: (message) => message,
         onMessage: (message) => {
           const { data: wsData, ts } = message;
-          const { asks, bids, prevTs } = wsData;
+          const { symbol: symbol2, asks, bids, prevTs } = wsData;
+          if (symbolRef.current !== symbol2) {
+            orderBookUpdateSub?.();
+            return;
+          }
           orderbook_service_default.updateOrderbook(
-            symbol,
+            symbol2,
             { asks, bids, ts, prevTs },
             () => needRequestFullOrderbook = true
           );
-          const data2 = orderbook_service_default.getRawOrderbook(symbol);
+          const data2 = orderbook_service_default.getRawOrderbook(symbol2);
           setData({ bids: data2.bids, asks: data2.asks });
         }
       }
@@ -2257,6 +2350,9 @@ var useOrderbookStream = (symbol, initial = INIT_DATA, options) => {
           formatter: (message) => message,
           onMessage: (message) => {
             const { symbol: symbol2, asks, bids, ts } = message.data;
+            if (symbolRef.current !== symbol2) {
+              return;
+            }
             orderbook_service_default.setFullOrderbook(symbol2, { asks, bids, ts });
             const data2 = orderbook_service_default.getRawOrderbook(symbol2);
             setData({ bids: data2.bids, asks: data2.asks });
@@ -3026,7 +3122,7 @@ var useLeverage = () => {
 };
 var useFundingRate = (symbol) => {
   if (!symbol) {
-    throw new Error("useFuturesForSymbol requires a symbol");
+    throw new types.SDKError("Symbol is required");
   }
   const [countDown, setCountDown] = React.useState("00:00:00");
   const { data } = useQuery(
@@ -3390,10 +3486,10 @@ var useOrderStream = (params, options) => {
   }, [orders?.length]);
   const cancelAlgoOrdersByTypes = (types$1) => {
     if (!types$1) {
-      throw new types.SDKError("types is required");
+      throw new types.SDKError("Types is required");
     }
     if (!Array.isArray(types$1)) {
-      throw new types.SDKError("types should be an array");
+      throw new types.SDKError("Types should be an array");
     }
     return Promise.all(
       types$1.map((type) => {
@@ -3494,7 +3590,7 @@ var useOrderStream = (params, options) => {
   const updateTPSLOrder = React.useCallback(
     (orderId, childOrders) => {
       if (!Array.isArray(childOrders)) {
-        throw new types.SDKError("children orders is required");
+        throw new types.SDKError("Children orders is required");
       }
       return doUpdateAlgoOrder({
         order_id: orderId,
@@ -3540,7 +3636,7 @@ var useOrderStream = (params, options) => {
 };
 var useMarketTradeStream = (symbol, options = {}) => {
   if (!symbol) {
-    throw new Error("useTradeStream: symbol is required");
+    throw new types.SDKError("Symbol is required");
   }
   const [trades, setTrades] = React.useState([]);
   const [isLoading, setIsLoading] = React.useState(false);
@@ -3769,7 +3865,13 @@ function useChains(networkId, options = {}) {
   );
   const { data: testTokenChainsRes } = useQuery(
     "https://testnet-api.orderly.org/v1/public/token",
-    { ...commonSwrOpts }
+    {
+      ...commonSwrOpts,
+      fallbackData: types.TesntTokenFallback([
+        types.ArbitrumSepoliaTokenInfo,
+        types.SolanaDevnetTokenInfo
+      ])
+    }
   );
   const brokerId = configStore.get("brokerId");
   const needFetchFromAPI = options.forceAPI || !customChains;
@@ -3777,9 +3879,14 @@ function useChains(networkId, options = {}) {
     needFetchFromAPI ? `https://api.orderly.org/v1/public/chain_info${brokerId !== "orderly" ? `?broker_id=${brokerId}` : ""}` : null,
     { ...commonSwrOpts }
   );
-  const { data: testChainInfos } = useQuery(
+  const { data: testChainInfos, error: testChainInfoError } = useQuery(
     needFetchFromAPI ? `https://testnet-api.orderly.org/v1/public/chain_info${brokerId !== "orderly" ? `?broker_id=${brokerId}` : ""}` : null,
-    { ...commonSwrOpts }
+    {
+      ...commonSwrOpts,
+      fallbackData: [types.ArbitrumSepoliaChainInfo, types.SolanaDevnetChainInfo],
+      onError: (error) => {
+      }
+    }
   );
   const chains = React.useMemo(() => {
     const tokenChains = fillChainsInfo(
@@ -3956,6 +4063,23 @@ function filterByAllowedChains(chains, allowedChains) {
     )
   );
 }
+function useStorageChain() {
+  const [chain, setChain] = useLocalStorage(types.ChainKey, null);
+  const setStorageChain = (chainId) => {
+    let namespace = types.ChainNamespace.evm;
+    if (types.SolanaChains.has(chainId)) {
+      namespace = types.ChainNamespace.solana;
+    }
+    setChain({
+      chainId,
+      namespace
+    });
+  };
+  return {
+    storageChain: chain,
+    setStorageChain
+  };
+}
 var useChain = (token) => {
   const { data, isLoading } = useQuery("/v1/public/token");
   const chains = React.useMemo(() => {
@@ -4031,6 +4155,7 @@ var useWithdraw = (options) => {
   const networkId = useConfig("networkId");
   const [_, { findByChainId }] = useChains(void 0);
   const ee = useEventEmitter();
+  const { track: track2 } = useTrack();
   const { usdc } = useHoldingStream();
   const maxAmount = React.useMemo(() => {
     return freeCollateral;
@@ -4072,7 +4197,7 @@ var useWithdraw = (options) => {
     (inputs) => {
       return account5.assetsManager.withdraw(inputs).then((res) => {
         if (res.success) {
-          ee.emit(types.EnumTrackerKeys.WITHDRAW_SUCCESS, {
+          ee.emit(types.EnumTrackerKeys.withdrawSuccess, {
             wallet: state?.connectWallet?.name,
             network: targetChain?.network_infos.name,
             quantity: inputs.amount
@@ -4080,7 +4205,7 @@ var useWithdraw = (options) => {
         }
         return res;
       }).catch((err) => {
-        ee.emit(types.EnumTrackerKeys.WITHDRAW_FAILED, {
+        track2(types.EnumTrackerKeys.withdrawFailed, {
           wallet: state?.connectWallet?.name,
           network: targetChain?.network_infos.name,
           msg: JSON.stringify(err)
@@ -4104,7 +4229,7 @@ var useDeposit = (options) => {
   const networkId = useConfig("networkId");
   const [balanceRevalidating, setBalanceRevalidating] = React.useState(false);
   const [allowanceRevalidating, setAllowanceRevalidating] = React.useState(false);
-  const ee = useEventEmitter();
+  useEventEmitter();
   const [_, { findByChainId }] = useChains(void 0);
   const [quantity, setQuantity] = React.useState("");
   const [depositFee, setDepositFee] = React.useState(0n);
@@ -4112,6 +4237,7 @@ var useDeposit = (options) => {
   const [balance, setBalance] = React.useState("0");
   const [allowance, setAllowance] = React.useState("0");
   const { account: account5, state } = useAccount();
+  const { track: track2 } = useTrack();
   const prevAddress = React.useRef();
   const getBalanceListener = React.useRef();
   const targetChain = React.useMemo(() => {
@@ -4277,7 +4403,7 @@ var useDeposit = (options) => {
   const approve = React.useCallback(
     async (amount) => {
       if (!options?.address) {
-        throw new Error("address is required");
+        throw new types.SDKError("Address is required");
       }
       return account5.assetsManager.approve({
         address: options.address,
@@ -4291,17 +4417,17 @@ var useDeposit = (options) => {
   );
   const deposit = React.useCallback(async () => {
     if (!options?.address) {
-      throw new Error("address is required");
+      throw new types.SDKError("Address is required");
     }
     const _allowance = await account5.assetsManager.getAllowance({
       address: options?.address
     });
     setAllowance(() => _allowance);
     if (new utils.Decimal(quantity).greaterThan(_allowance)) {
-      throw new Error("Insufficient allowance");
+      throw new types.SDKError("Insufficient allowance");
     }
     return account5.assetsManager.deposit(quantity, depositFee).then((res) => {
-      ee.emit(types.EnumTrackerKeys.DEPOSIT_SUCCESS, {
+      track2(types.EnumTrackerKeys.depositSuccess, {
         wallet: state?.connectWallet?.name,
         network: targetChain?.network_infos.name,
         quantity
@@ -4310,7 +4436,7 @@ var useDeposit = (options) => {
       setBalance((value) => new utils.Decimal(value).sub(quantity).toString());
       return res;
     }).catch((e) => {
-      ee.emit(types.EnumTrackerKeys.DEPOSIT_FAILED, {
+      track2(types.EnumTrackerKeys.depositFailed, {
         wallet: state?.connectWallet?.name,
         network: targetChain?.network_infos?.name,
         msg: JSON.stringify(e)
@@ -4706,6 +4832,26 @@ function tpslCalculateHelper(key, inputs, options = {}) {
     // }),
   };
 }
+function getMinNotional(props) {
+  const { price, base_tick, qty, min_notional, base_dp, quote_dp, quote_tick } = props;
+  if (price !== void 0 && qty !== void 0 && min_notional !== void 0) {
+    try {
+      const calcNotional = new utils.Decimal(price).mul(new utils.Decimal(qty)).toNumber();
+      const notional = Number.parseFloat(`${min_notional}`);
+      if (calcNotional < notional) {
+        let minQty = new utils.Decimal(notional).div(price).toDecimalPlaces(base_dp, utils.Decimal.ROUND_DOWN).add(base_tick ?? 0);
+        if (base_tick && base_tick > 0) {
+          minQty = new utils.Decimal(
+            getRoundedDownDivision(minQty.toNumber(), base_tick)
+          );
+        }
+        const newMinNotional = minQty.mul(price).add(quote_tick ?? 0).toFixed(quote_dp);
+        return newMinNotional;
+      }
+    } catch (e) {
+    }
+  }
+}
 function checkNotional(props) {
   const { price, base_tick, qty, min_notional, base_dp, quote_dp, quote_tick } = props;
   if (price !== void 0 && qty !== void 0 && min_notional !== void 0) {
@@ -4736,6 +4882,47 @@ function getRoundedDownDivision(value, tick) {
   return quotient.mul(decimalTick).toNumber();
 }
 
+// src/services/orderCreator/orderValidation.ts
+var OrderValidation = class {
+  static getLabel(key) {
+    switch (key) {
+      case "quantity":
+      case "order_quantity":
+        return "Quantity";
+      case "order_price":
+        return "Price";
+      case "trigger_price":
+        return "Trigger price";
+      case "tp_trigger_price":
+        return "TP price";
+      case "sl_trigger_price":
+        return "SL price";
+      default:
+        return key;
+    }
+  }
+  static required(key) {
+    return {
+      type: "required",
+      message: `${this.getLabel(key)} is required`
+    };
+  }
+  static min(key, value) {
+    return {
+      type: "min",
+      message: `${this.getLabel(key)} must be greater than ${value}`,
+      value
+    };
+  }
+  static max(key, value) {
+    return {
+      type: "max",
+      message: `${this.getLabel(key)} must be less than ${value}`,
+      value
+    };
+  }
+};
+
 // src/services/orderCreator/baseCreator.ts
 var BaseOrderCreator = class {
   baseOrder(data) {
@@ -4774,31 +4961,24 @@ var BaseOrderCreator = class {
       }
     }
     if (!order_quantity) {
-      errors.order_quantity = {
-        type: "required",
-        message: "Quantity is required"
-      };
+      errors.order_quantity = OrderValidation.required("order_quantity");
     } else {
       const { base_min, quote_dp: quote_dp2, base_dp: base_dp2 } = 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_dp2
-          )}`
-        };
+        errors.order_quantity = OrderValidation.min(
+          "order_quantity",
+          new utils.Decimal(base_min).todp(base_dp2).toString()
+        );
       } else if (qty.gt(maxQty)) {
-        errors.order_quantity = {
-          type: "max",
-          message: `Quantity must be less than ${new utils.Decimal(maxQty).todp(
-            base_dp2
-          )}`
-        };
+        errors.order_quantity = OrderValidation.max(
+          "order_quantity",
+          new utils.Decimal(maxQty).todp(base_dp2).toString()
+        );
       }
     }
     const price = `${order_type}`.includes("MARKET") ? markPrice : order_price;
-    const notionalHintStr = checkNotional({
+    const minNotional = getMinNotional({
       base_tick,
       quote_tick,
       price,
@@ -4807,10 +4987,11 @@ var BaseOrderCreator = class {
       quote_dp,
       base_dp
     });
-    if (notionalHintStr !== void 0 && !reduce_only) {
+    if (minNotional !== void 0 && !reduce_only) {
       errors.total = {
         type: "min",
-        message: notionalHintStr
+        message: `The order value should be greater or equal to ${minNotional} USDC`,
+        value: minNotional
       };
     }
     this.validateBracketOrder(values2, configs, errors);
@@ -4875,62 +5056,62 @@ var BaseOrderCreator = class {
     if (hasTPPrice) {
       const tpPrice = new utils.Decimal(tp_trigger_price);
       if (tpPrice.gt(quote_max)) {
-        errors.tp_trigger_price = {
-          type: "max",
-          message: `TP price must be less than ${quote_max}`
-        };
+        errors.tp_trigger_price = OrderValidation.max(
+          "tp_trigger_price",
+          quote_max
+        );
       }
       if (tpPrice.lt(quote_min)) {
-        errors.tp_trigger_price = {
-          type: "min",
-          message: `TP price must be greater than ${quote_min}`
-        };
+        errors.tp_trigger_price = OrderValidation.min(
+          "tp_trigger_price",
+          quote_min
+        );
       }
       if (side === types.OrderSide.BUY) {
         if (tpPrice.lte(_orderPrice)) {
-          errors.tp_trigger_price = {
-            type: "tpPrice < order_price",
-            message: `TP must be greater than ${_orderPrice}`
-          };
+          errors.tp_trigger_price = OrderValidation.min(
+            "tp_trigger_price",
+            _orderPrice
+          );
         }
       }
       if (side === types.OrderSide.SELL) {
         if (tpPrice.gte(_orderPrice)) {
-          errors.tp_trigger_price = {
-            type: "tpPrice > order_price",
-            message: `TP price must be less than ${_orderPrice}`
-          };
+          errors.tp_trigger_price = OrderValidation.max(
+            "tp_trigger_price",
+            _orderPrice
+          );
         }
       }
     }
     if (hasSLPrice) {
       const slPrice = new utils.Decimal(sl_trigger_price);
       if (slPrice.gt(quote_max)) {
-        errors.sl_trigger_price = {
-          type: "max",
-          message: `SL price must be less than ${quote_max}`
-        };
+        errors.sl_trigger_price = OrderValidation.max(
+          "sl_trigger_price",
+          quote_max
+        );
       }
       if (slPrice.lt(quote_min)) {
-        errors.sl_trigger_price = {
-          type: "min",
-          message: `SL price must be greater than ${quote_min}`
-        };
+        errors.sl_trigger_price = OrderValidation.min(
+          "sl_trigger_price",
+          quote_min
+        );
       }
       if (side === types.OrderSide.BUY) {
         if (slPrice.gte(_orderPrice)) {
-          errors.sl_trigger_price = {
-            type: "slPrice > order_price",
-            message: `SL price must be less than ${_orderPrice}`
-          };
+          errors.sl_trigger_price = OrderValidation.max(
+            "sl_trigger_price",
+            _orderPrice
+          );
         }
       }
       if (side === types.OrderSide.SELL) {
         if (slPrice.lte(_orderPrice)) {
-          errors.sl_trigger_price = {
-            type: "slPrice < order_price",
-            message: `SL price must be greater than ${_orderPrice}`
-          };
+          errors.sl_trigger_price = OrderValidation.min(
+            "sl_trigger_price",
+            _orderPrice
+          );
         }
       }
     }
@@ -4985,10 +5166,7 @@ var LimitOrderCreator = class extends BaseOrderCreator {
     return this.baseValidate(values2, config).then((errors) => {
       const { order_price, side } = values2;
       if (!order_price) {
-        errors.order_price = {
-          type: "required",
-          message: "Price is required"
-        };
+        errors.order_price = OrderValidation.required("order_price");
       } else {
         const price = new utils.Decimal(order_price);
         const { symbol } = config;
@@ -5008,33 +5186,23 @@ var LimitOrderCreator = class extends BaseOrderCreator {
           max: scopePriceNumber
         };
         if (price.gt(quote_max)) {
-          errors.order_price = {
-            type: "max",
-            message: `Price must be less than ${quote_max}`
-          };
+          errors.order_price = OrderValidation.max("order_price", quote_max);
         } else {
           if (price.gt(priceRange?.max)) {
-            errors.order_price = {
-              type: "max",
-              message: `Price must be less than ${new utils.Decimal(
-                priceRange.max
-              ).todp(symbol.quote_dp)}`
-            };
+            errors.order_price = OrderValidation.max(
+              "order_price",
+              new utils.Decimal(priceRange.max).todp(symbol.quote_dp).toString()
+            );
           }
         }
         if (price.lt(quote_min)) {
-          errors.order_price = {
-            type: "min",
-            message: `Price must be greater than ${quote_min}`
-          };
+          errors.order_price = OrderValidation.min("order_price", quote_min);
         } else {
           if (price.lt(priceRange?.min)) {
-            errors.order_price = {
-              type: "min",
-              message: `Price must be greater than ${new utils.Decimal(
-                priceRange.min
-              ).todp(symbol.quote_dp)}`
-            };
+            errors.order_price = OrderValidation.min(
+              "order_price",
+              new utils.Decimal(priceRange.min).todp(symbol.quote_dp).toString()
+            );
           }
         }
       }
@@ -5081,27 +5249,15 @@ var StopLimitOrderCreator = class extends BaseOrderCreator {
       const { symbol } = config;
       const { price_range, price_scope, quote_max, quote_min } = symbol;
       if (!trigger_price) {
-        errors.trigger_price = {
-          type: "required",
-          message: "Trigger price is required"
-        };
+        errors.trigger_price = OrderValidation.required("trigger_price");
       }
       if (!order_price) {
-        errors.order_price = {
-          type: "required",
-          message: "Price is required"
-        };
+        errors.order_price = OrderValidation.required("order_price");
       }
       if (trigger_price > quote_max) {
-        errors.trigger_price = {
-          type: "max",
-          message: `Trigger price must be less than ${quote_max}`
-        };
+        errors.trigger_price = OrderValidation.max("trigger_price", quote_max);
       } else if (trigger_price < quote_min) {
-        errors.trigger_price = {
-          type: "min",
-          message: `Trigger price must be greater than ${quote_min}`
-        };
+        errors.trigger_price = OrderValidation.min("trigger_price", quote_min);
       } else {
         if (trigger_price && order_price) {
           const price = new utils.Decimal(order_price);
@@ -5120,33 +5276,23 @@ var StopLimitOrderCreator = class extends BaseOrderCreator {
             max: scropePriceNumbere
           };
           if (price.gt(quote_max)) {
-            errors.order_price = {
-              type: "max",
-              message: `Price must be less than ${quote_max}`
-            };
+            errors.order_price = OrderValidation.max("order_price", quote_max);
           } else {
             if (price.gt(priceRange?.max)) {
-              errors.order_price = {
-                type: "max",
-                message: `Price must be less than ${new utils.Decimal(
-                  priceRange.max
-                ).todp(symbol.quote_dp)}`
-              };
+              errors.order_price = OrderValidation.max(
+                "order_price",
+                new utils.Decimal(priceRange.max).todp(symbol.quote_dp).toString()
+              );
             }
           }
           if (price.lt(quote_min)) {
-            errors.order_price = {
-              type: "min",
-              message: `Price must be greater than ${quote_min}`
-            };
+            errors.order_price = OrderValidation.min("order_price", quote_min);
           } else {
             if (price.lt(priceRange?.min)) {
-              errors.order_price = {
-                type: "min",
-                message: `Price must be greater than ${new utils.Decimal(
-                  priceRange.min
-                ).todp(symbol.quote_dp)}`
-              };
+              errors.order_price = OrderValidation.min(
+                "order_price",
+                new utils.Decimal(priceRange.min).todp(symbol.quote_dp).toString()
+              );
             }
           }
         }
@@ -5203,21 +5349,12 @@ var StopMarketOrderCreator = class extends BaseOrderCreator {
       const { symbol } = config;
       const { quote_max, quote_min } = symbol;
       if (!trigger_price) {
-        errors.trigger_price = {
-          type: "required",
-          message: "Trigger price is required"
-        };
+        errors.trigger_price = OrderValidation.required("trigger_price");
       }
       if (trigger_price > quote_max) {
-        errors.trigger_price = {
-          type: "max",
-          message: `Trigger price must be less than ${quote_max}`
-        };
+        errors.trigger_price = OrderValidation.max("trigger_price", quote_max);
       } else if (trigger_price < quote_min) {
-        errors.trigger_price = {
-          type: "min",
-          message: `Trigger price must be greater than ${quote_min}`
-        };
+        errors.trigger_price = OrderValidation.min("trigger_price", quote_min);
       }
       return errors;
     });
@@ -5246,82 +5383,91 @@ var BaseAlgoOrderCreator = class {
       const qty = Number(values2.quantity);
       const maxQty = config.maxQty;
       const orderType = values2.order_type;
-      const { quote_max, quote_min, price_scope, quote_dp, base_min, min_notional } = config.symbol ?? {};
+      const {
+        quote_max,
+        quote_min,
+        price_scope,
+        quote_dp,
+        base_min,
+        min_notional
+      } = config.symbol ?? {};
       if (!isNaN(qty) && qty > maxQty) {
-        result.quantity = {
-          message: `Quantity must be less than ${config.maxQty}`
-        };
+        result.quantity = OrderValidation.max("quantity", config.maxQty);
       }
       if (!isNaN(qty) && qty < base_min) {
-        result.quantity = {
-          message: `Quantity must be greater than ${base_min}`
-        };
+        result.quantity = OrderValidation.min("quantity", base_min);
       }
       if (Number(tp_trigger_price) < 0) {
-        result.tp_trigger_price = {
-          message: `TP Price must be greater than 0`
-        };
+        result.tp_trigger_price = OrderValidation.min("tp_trigger_price", 0);
       }
       if (Number(sl_trigger_price) < 0) {
-        result.sl_trigger_price = {
-          message: `SL Price must be greater than 0`
-        };
+        result.sl_trigger_price = OrderValidation.min("sl_trigger_price", 0);
       }
       const mark_price = orderType === types.OrderType.MARKET || orderType == null ? config.markPrice : values2.order_price ? Number(values2.order_price) : void 0;
       if (side === types.OrderSide.BUY && mark_price) {
         const slTriggerPriceScope = new utils.Decimal(mark_price * (1 - price_scope)).toDecimalPlaces(quote_dp, utils.Decimal.ROUND_DOWN).toNumber();
         if (!!sl_trigger_price && Number(sl_trigger_price) < slTriggerPriceScope) {
-          result.sl_trigger_price = {
-            message: `SL price must be greater than ${slTriggerPriceScope}`
-          };
+          result.sl_trigger_price = OrderValidation.min(
+            "sl_trigger_price",
+            slTriggerPriceScope
+          );
         }
         if (!!sl_trigger_price && Number(sl_trigger_price) > config.markPrice) {
-          result.sl_trigger_price = {
-            message: `SL price must be less than ${config.markPrice}`
-          };
+          result.sl_trigger_price = OrderValidation.max(
+            "sl_trigger_price",
+            config.markPrice
+          );
         }
         if (!!tp_trigger_price && Number(tp_trigger_price) <= config.markPrice) {
-          result.tp_trigger_price = {
-            message: `TP price must be greater than ${config.markPrice}`
-          };
+          result.tp_trigger_price = OrderValidation.min(
+            "tp_trigger_price",
+            config.markPrice
+          );
         }
         if (!!tp_trigger_price && Number(tp_trigger_price) > quote_max) {
-          result.tp_trigger_price = {
-            message: `TP price must be less than ${quote_max}`
-          };
+          result.tp_trigger_price = OrderValidation.max(
+            "tp_trigger_price",
+            quote_max
+          );
         }
         if (!!sl_trigger_price && Number(sl_trigger_price) < quote_min) {
-          result.sl_trigger_price = {
-            message: `TP price must be greater than ${quote_min}`
-          };
+          result.sl_trigger_price = OrderValidation.min(
+            "sl_trigger_price",
+            quote_min
+          );
         }
       }
       if (side === types.OrderSide.SELL && mark_price) {
         const slTriggerPriceScope = new utils.Decimal(mark_price * (1 + price_scope)).toDecimalPlaces(quote_dp, utils.Decimal.ROUND_DOWN).toNumber();
         if (!!sl_trigger_price && Number(sl_trigger_price) > slTriggerPriceScope) {
-          result.sl_trigger_price = {
-            message: `SL price must be less than ${slTriggerPriceScope}`
-          };
+          result.sl_trigger_price = OrderValidation.max(
+            "sl_trigger_price",
+            slTriggerPriceScope
+          );
         }
         if (!!sl_trigger_price && Number(sl_trigger_price) < config.markPrice) {
-          result.sl_trigger_price = {
-            message: `SL price must be greater than ${config.markPrice}`
-          };
+          result.sl_trigger_price = OrderValidation.min(
+            "sl_trigger_price",
+            config.markPrice
+          );
         }
         if (!!tp_trigger_price && Number(tp_trigger_price) >= config.markPrice) {
-          result.tp_trigger_price = {
-            message: `TP price must be less than ${config.markPrice}`
-          };
+          result.tp_trigger_price = OrderValidation.max(
+            "tp_trigger_price",
+            config.markPrice
+          );
         }
         if (!!tp_trigger_price && Number(tp_trigger_price) > quote_max) {
-          result.tp_trigger_price = {
-            message: `TP price must be less than ${quote_max}`
-          };
+          result.tp_trigger_price = OrderValidation.max(
+            "tp_trigger_price",
+            quote_max
+          );
         }
         if (!!sl_trigger_price && Number(sl_trigger_price) < quote_min) {
-          result.sl_trigger_price = {
-            message: `TP price must be greater than ${quote_min}`
-          };
+          result.sl_trigger_price = OrderValidation.min(
+            "sl_trigger_price",
+            quote_min
+          );
         }
       }
       return Object.keys(result).length > 0 ? result : null;
@@ -5493,64 +5639,66 @@ async function bracketOrderValidator(values2, config) {
   const { quote_max, quote_min, price_scope, quote_dp } = config.symbol ?? {};
   const mark_price = type === types.OrderType.MARKET ? config.markPrice : values2.order_price ? Number(values2.order_price) : void 0;
   if (!isNaN(qty) && qty > maxQty) {
-    result.quantity = {
-      message: `Quantity must be less than ${config.maxQty}`
-    };
+    result.quantity = OrderValidation.max("quantity", config.maxQty);
   }
   if (Number(tp_trigger_price) < 0) {
-    result.tp_trigger_price = {
-      message: `TP Price must be greater than 0`
-    };
+    result.tp_trigger_price = OrderValidation.min("tp_trigger_price", 0);
   }
   if (Number(sl_trigger_price) < 0) {
-    result.sl_trigger_price = {
-      message: `SL Price must be greater than 0`
-    };
+    result.sl_trigger_price = OrderValidation.min("sl_trigger_price", 0);
   }
   if (side === types.OrderSide.BUY && mark_price) {
     const slTriggerPriceScope = new utils.Decimal(mark_price * (1 - price_scope)).toDecimalPlaces(quote_dp, utils.Decimal.ROUND_DOWN).toNumber();
     if (!!sl_trigger_price && Number(sl_trigger_price) < slTriggerPriceScope) {
-      result.sl_trigger_price = {
-        message: `SL price must be greater than ${slTriggerPriceScope}`
-      };
+      result.sl_trigger_price = OrderValidation.min(
+        "sl_trigger_price",
+        slTriggerPriceScope
+      );
     }
     if (!!tp_trigger_price && Number(tp_trigger_price) <= mark_price) {
-      result.tp_trigger_price = {
-        message: `TP price must be greater than ${mark_price}`
-      };
+      result.tp_trigger_price = OrderValidation.min(
+        "tp_trigger_price",
+        mark_price
+      );
     }
     if (!!tp_trigger_price && Number(tp_trigger_price) > quote_max) {
-      result.tp_trigger_price = {
-        message: `TP price must be less than ${quote_max}`
-      };
+      result.tp_trigger_price = OrderValidation.max(
+        "tp_trigger_price",
+        quote_max
+      );
     }
     if (!!sl_trigger_price && Number(sl_trigger_price) < quote_min) {
-      result.sl_trigger_price = {
-        message: `TP price must be greater than ${quote_min}`
-      };
+      result.sl_trigger_price = OrderValidation.min(
+        "sl_trigger_price",
+        quote_min
+      );
     }
   }
   if (side === types.OrderSide.SELL && mark_price) {
     const slTriggerPriceScope = new utils.Decimal(mark_price * (1 + price_scope)).toDecimalPlaces(quote_dp, utils.Decimal.ROUND_DOWN).toNumber();
     if (!!sl_trigger_price && Number(sl_trigger_price) > slTriggerPriceScope) {
-      result.sl_trigger_price = {
-        message: `SL price must be less than ${slTriggerPriceScope}`
-      };
+      result.sl_trigger_price = OrderValidation.max(
+        "sl_trigger_price",
+        slTriggerPriceScope
+      );
     }
     if (!!tp_trigger_price && Number(tp_trigger_price) >= mark_price) {
-      result.tp_trigger_price = {
-        message: `TP price must be less than ${mark_price}`
-      };
+      result.tp_trigger_price = OrderValidation.max(
+        "tp_trigger_price",
+        mark_price
+      );
     }
     if (!!tp_trigger_price && Number(tp_trigger_price) > quote_max) {
-      result.tp_trigger_price = {
-        message: `TP price must be less than ${quote_max}`
-      };
+      result.tp_trigger_price = OrderValidation.max(
+        "tp_trigger_price",
+        quote_max
+      );
     }
     if (!!sl_trigger_price && Number(sl_trigger_price) < quote_min) {
-      result.sl_trigger_price = {
-        message: `TP price must be greater than ${quote_min}`
-      };
+      result.sl_trigger_price = OrderValidation.min(
+        "sl_trigger_price",
+        quote_min
+      );
     }
   }
   return Object.keys(result).length > 0 ? result : null;
@@ -5619,7 +5767,7 @@ var BBOOrderCreator = class extends BaseOrderCreator {
       let { order_quantity, order_price, reduce_only, level } = values2;
       const { symbol } = configs;
       const { min_notional, base_tick, quote_dp, quote_tick, base_dp } = symbol || {};
-      const notionalHintStr = checkNotional({
+      const minNotional = getMinNotional({
         base_tick,
         quote_tick,
         price: order_price,
@@ -5628,10 +5776,11 @@ var BBOOrderCreator = class extends BaseOrderCreator {
         quote_dp,
         base_dp
       });
-      if (notionalHintStr !== void 0 && !reduce_only) {
+      if (minNotional !== void 0 && !reduce_only) {
         errors.total = {
           type: "min",
-          message: notionalHintStr
+          message: `The order value should be greater or equal to ${minNotional} USDC`,
+          value: minNotional
         };
       }
       return errors;
@@ -5922,12 +6071,12 @@ var useSymbolLeverage = (symbol) => {
   return maxLeverage;
 };
 var AssetHistoryStatusEnum = /* @__PURE__ */ ((AssetHistoryStatusEnum2) => {
-  AssetHistoryStatusEnum2["NEW"] = "new";
-  AssetHistoryStatusEnum2["CONFIRM"] = "confirm";
-  AssetHistoryStatusEnum2["PROCESSING"] = "processing";
-  AssetHistoryStatusEnum2["COMPLETED"] = "completed";
-  AssetHistoryStatusEnum2["PENDDING"] = "pendding";
-  AssetHistoryStatusEnum2["PENDING_REBALANCE"] = "pending_rebalance";
+  AssetHistoryStatusEnum2["NEW"] = "NEW";
+  AssetHistoryStatusEnum2["CONFIRM"] = "CONFIRM";
+  AssetHistoryStatusEnum2["PROCESSING"] = "PROCESSING";
+  AssetHistoryStatusEnum2["COMPLETED"] = "COMPLETED";
+  AssetHistoryStatusEnum2["FAILED"] = "FAILED";
+  AssetHistoryStatusEnum2["PENDING_REBALANCE"] = "PENDING_REBALANCE";
   return AssetHistoryStatusEnum2;
 })(AssetHistoryStatusEnum || {});
 var useAssetsHistory = (options) => {
@@ -5978,7 +6127,7 @@ var useStatisticsDaily = (params, options) => {
   const { startDate, endDate, page = 1 } = params;
   const { ignoreAggregation = false } = options || {};
   if (!startDate || !endDate) {
-    throw new types.SDKError("startDate and endDate are required");
+    throw new types.SDKError("Start date and end date are required");
   }
   const getPeriod = (startDate2, endDate2) => {
     if (startDate2 === endDate2) {
@@ -6124,11 +6273,14 @@ function useMaintenanceStatus() {
   const [startTime, setStartTime] = React.useState();
   const [endTime, setEndTime] = React.useState();
   const [brokerName, setBrokerName] = React.useState("Orderly network");
-  const { data: systemInfo, mutate: mutate3 } = useQuery(`/v1/public/system_info?source=maintenance`, {
-    revalidateOnFocus: false,
-    errorRetryCount: 2,
-    errorRetryInterval: 200
-  });
+  const { data: systemInfo, mutate: mutate3 } = useQuery(
+    `/v1/public/system_info?source=maintenance`,
+    {
+      revalidateOnFocus: false,
+      errorRetryCount: 2,
+      errorRetryInterval: 200
+    }
+  );
   const ws = useWS();
   const config = useConfig();
   React.useEffect(() => {
@@ -6567,7 +6719,7 @@ var ProxyConfigStore = class {
     (this._proxyConfigStore ?? this._originConfigStore).set(key, value);
   }
   clear() {
-    throw new Error("Method not implemented.");
+    throw new types.SDKError("Method not implemented.");
   }
   getFromOrigin(key) {
     return this._originConfigStore.get(key);
@@ -6688,91 +6840,6 @@ var OrderlyConfigProvider = (props) => {
     }
   );
 };
-var apiKeyMap = {
-  dev: "4d6b7db0fdd6e9de2b6a270414fd51e0",
-  qa: "96476b00bc2701360f9b480629ae5263",
-  staging: "dffc00e003479b86d410c448e00f2304",
-  prod: "3ab9ae56ed16cc57bc2ac97ffc1098c2"
-};
-var TrackerContext = React.createContext({});
-var OrderlyTrackerProvider = ({ children }) => {
-  const listenKeys = Object.keys(types.TrackerListenerKeyMap);
-  const ee = useEventEmitter();
-  const env = useGetEnv();
-  const walletConnectRef = React.useRef(false);
-  const { account: account5, state } = useAccount();
-  const networkId = useConfig("networkId");
-  const brokerId = useConfig("brokerId");
-  const getChainInfo = useNetworkInfo(networkId);
-  const handleEvent = React.useCallback(
-    (key, params) => {
-      account5?.accountId && amplitude__namespace.setUserId(account5?.accountId);
-      if (key === types.EnumTrackerKeys.WALLET_CONNECT) {
-        if (walletConnectRef.current)
-          return;
-        const info = getChainInfo(
-          params?.connectWallet?.chainId
-        ).info;
-        const { address = "", connectWallet } = params;
-        const identify2 = {
-          address,
-          broker_id: brokerId,
-          sdk_version: window?.__ORDERLY_VERSION__?.["@orderly.network/net"] ?? ""
-        };
-        const identifyEvent = new amplitude__namespace.Identify();
-        Object.keys(identify2).map((subKey) => {
-          identifyEvent.set(subKey, identify2[subKey]);
-        });
-        amplitude__namespace.identify(identifyEvent);
-        const eventProperties = {
-          wallet: connectWallet?.name,
-          network: info?.network_infos?.name
-        };
-        amplitude__namespace.track(types.TrackerListenerKeyMap[key], eventProperties);
-        walletConnectRef.current = true;
-        return;
-      }
-      if (key === types.EnumTrackerKeys.SIGNIN_SUCCESS) {
-        const info = getChainInfo(
-          params?.connectWallet?.chainId
-        ).info;
-        amplitude__namespace.track(types.TrackerListenerKeyMap[key], {
-          wallet: params?.connectWallet?.name,
-          network: info?.network_infos?.name
-        });
-        return;
-      }
-      amplitude__namespace.track(types.TrackerListenerKeyMap[key], params);
-    },
-    [account5?.accountId, brokerId, state?.connectWallet?.name]
-  );
-  React.useEffect(() => {
-    amplitude__namespace.init(apiKeyMap[env], { serverZone: "EU" });
-    listenKeys.forEach((key) => {
-      ee.on(key, (params = {}) => {
-        setTimeout(() => {
-          handleEvent(key, params);
-        }, 2e3);
-      });
-    });
-    return () => {
-      listenKeys.forEach((key) => {
-        ee.off(key);
-      });
-    };
-  }, [env]);
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    TrackerContext.Provider,
-    {
-      value: {
-        track: (key, params) => {
-          amplitude__namespace.track(key, params);
-        }
-      },
-      children
-    }
-  );
-};
 var WalletConnectorContext = React.createContext({});
 var useWalletConnector = () => {
   return React.useContext(WalletConnectorContext);
@@ -7019,13 +7086,13 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
   if (typeof symbolOrOrder === "object") {
     isNewVersion = true;
     if (!symbolOrOrder.symbol) {
-      throw new types.SDKError("symbol is required");
+      throw new types.SDKError("Symbol is required");
     }
     if (!symbolOrOrder.side) {
       throw new types.SDKError("Order side is required");
     }
     if (!symbolOrOrder.order_type) {
-      throw new types.SDKError("order_type is required");
+      throw new types.SDKError("Order type is required");
     }
   }
   const prevOrderData = React.useRef(null);
@@ -7186,20 +7253,20 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
   );
   const createOrder = (values2) => {
     if (!values2.symbol) {
-      throw new types.SDKError("symbol is error");
+      throw new types.SDKError("Symbol is error");
     }
     if (!values2.side) {
-      throw new types.SDKError("side is error");
+      throw new types.SDKError("Order side is error");
     }
     if (!values2 || typeof values2.order_type === "undefined") {
-      throw new types.SDKError("order_type is error");
+      throw new types.SDKError("Order type is error");
     }
     const orderCreator = OrderFactory.create(
       // @ts-ignore
       values2.order_type_ext ? values2.order_type_ext : values2.order_type
     );
     if (!orderCreator) {
-      return Promise.reject(new types.SDKError("orderCreator is null"));
+      return Promise.reject(new types.SDKError("Order creator is null"));
     }
     return new Promise((resolve, reject) => {
       return orderCreator.validate(values2, {
@@ -14087,9 +14154,10 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
 };
 var useOrderEntry2 = (symbol, options = {}) => {
   if (!symbol) {
-    throw new types.SDKError("symbol is required and must be a string");
+    throw new types.SDKError("Symbol is required");
   }
   const ee = useEventEmitter();
+  const { track: track2 } = useTrack();
   const [meta, setMeta] = React.useState({
     dirty: {},
     submitted: false,
@@ -14241,28 +14309,30 @@ var useOrderEntry2 = (symbol, options = {}) => {
     return validate(order, creator, prepareData());
   }
   const validateOrder = () => {
-    return new Promise(async (resolve, reject) => {
-      const creator = getOrderCreator(formattedOrder);
-      const errors = await validate(formattedOrder, creator, prepareData());
-      const keys = Object.keys(errors);
-      if (keys.length > 0) {
-        setMeta(
-          immer$1.produce((draft) => {
-            draft.errors = errors;
-          })
-        );
-        if (!meta.validated) {
+    return new Promise(
+      async (resolve, reject) => {
+        const creator = getOrderCreator(formattedOrder);
+        const errors = await validate(formattedOrder, creator, prepareData());
+        const keys = Object.keys(errors);
+        if (keys.length > 0) {
           setMeta(
             immer$1.produce((draft) => {
-              draft.validated = true;
+              draft.errors = errors;
             })
           );
+          if (!meta.validated) {
+            setMeta(
+              immer$1.produce((draft) => {
+                draft.validated = true;
+              })
+            );
+          }
+          reject(errors);
         }
-        reject(errors);
+        const order = generateOrder(creator, prepareData());
+        resolve(order);
       }
-      const order = generateOrder(creator, prepareData());
-      resolve(order);
-    });
+    );
   };
   const { freeCollateral, totalCollateral } = useCollateral();
   const estLiqPrice = React.useMemo(() => {
@@ -14329,12 +14399,12 @@ var useOrderEntry2 = (symbol, options = {}) => {
           draft.errors = errors;
         })
       );
-      throw new Error("Order validation failed");
+      throw new types.SDKError("Order validation failed");
     }
     const order = generateOrder(creator, prepareData());
     const result = await doCreateOrder(order);
     if (result.success) {
-      ee.emit(types.EnumTrackerKeys.PLACEORDER_SUCCESS, {
+      track2(types.EnumTrackerKeys.placeorderSuccess, {
         side: order.side,
         order_type: order.order_type,
         tp_sl: hasTPSL(formattedOrder),
@@ -14462,7 +14532,7 @@ var useOrderStore2 = zustand.create()(
 );
 var useOrderEntity = (order, options) => {
   if (!order.symbol) {
-    throw new types.SDKError("symbol is required");
+    throw new types.SDKError("Symbol is required");
   }
   const [errors, setErrors] = React.useState();
   const maxQty = useMaxQty(order.symbol, order.side, order.reduce_only);
@@ -14477,27 +14547,29 @@ var useOrderEntity = (order, options) => {
   }, [finalMaxQty, order.symbol, order]);
   const symbolInfo = useSymbolsInfo();
   const validate = () => {
-    return new Promise(async (resolve, reject) => {
-      const creator = getOrderCreator(order);
-      const _symbol = symbolInfo[order.symbol]();
-      const errors2 = await creator?.validate(order, {
-        symbol: _symbol,
-        maxQty: finalMaxQty,
-        markPrice
-      });
-      const keys = Object.keys(errors2);
-      if (keys.length > 0) {
-        setErrors(errors2);
-        reject(errors2);
-      } else {
-        setErrors({});
+    return new Promise(
+      async (resolve, reject) => {
+        const creator = getOrderCreator(order);
+        const _symbol = symbolInfo[order.symbol]();
+        const errors2 = await creator?.validate(order, {
+          symbol: _symbol,
+          maxQty: finalMaxQty,
+          markPrice
+        });
+        const keys = Object.keys(errors2);
+        if (keys.length > 0) {
+          setErrors(errors2);
+          reject(errors2);
+        } else {
+          setErrors({});
+        }
+        const orderEntity = creator.create(order, {
+          ...prepareData(),
+          symbol: _symbol
+        });
+        resolve(orderEntity);
       }
-      const orderEntity = creator.create(order, {
-        ...prepareData(),
-        symbol: _symbol
-      });
-      resolve(orderEntity);
-    });
+    );
   };
   const autoCheck = useDebounce.useThrottledCallback(
     () => {
@@ -14612,7 +14684,6 @@ exports.MarketsType = MarketsType;
 exports.OrderlyConfigProvider = OrderlyConfigProvider;
 exports.OrderlyContext = OrderlyContext;
 exports.OrderlyProvider = OrderlyProvider;
-exports.OrderlyTrackerProvider = OrderlyTrackerProvider;
 exports.StatusContext = StatusContext;
 exports.StatusProvider = StatusProvider;
 exports.TWType = TWType;
@@ -14620,6 +14691,7 @@ exports.WalletConnectorContext = WalletConnectorContext;
 exports.WsNetworkStatus = WsNetworkStatus;
 exports.checkNotional = checkNotional;
 exports.cleanStringStyle = cleanStringStyle;
+exports.getMinNotional = getMinNotional;
 exports.parseJSON = parseJSON;
 exports.useAccount = useAccount;
 exports.useAccountInfo = useAccountInfo2;
@@ -14693,12 +14765,15 @@ exports.useSessionStorage = useSessionStorage;
 exports.useSettleSubscription = useSettleSubscription;
 exports.useSimpleDI = useSimpleDI;
 exports.useStatisticsDaily = useStatisticsDaily;
+exports.useStorageChain = useStorageChain;
 exports.useStorageLedgerAddress = useStorageLedgerAddress;
 exports.useSymbolLeverage = useSymbolLeverage;
 exports.useSymbolPriceRange = useSymbolPriceRange;
 exports.useSymbolsInfo = useSymbolsInfo;
 exports.useTPSLOrder = useTPSLOrder;
 exports.useTickerStream = useTickerStream;
+exports.useTrack = useTrack;
+exports.useTrackingInstance = useTrackingInstance;
 exports.useWS = useWS;
 exports.useWalletConnector = useWalletConnector;
 exports.useWalletRewardsHistory = useWalletRewardsHistory;