@orderly.network/hooks 2.6.1 → 2.6.2

package/dist/index.js

@@ -61,9 +61,9 @@ var __export = (target, all) => {
 // src/version.ts
 if (typeof window !== "undefined") {
   window.__ORDERLY_VERSION__ = window.__ORDERLY_VERSION__ || {};
-  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.6.1";
+  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.6.2";
 }
-var version_default = "2.6.1";
+var version_default = "2.6.2";
 var fetcher = (url, init2 = {}, queryOptions) => net.get(url, init2, queryOptions?.formatter);
 var OrderlyContext = React2.createContext({
   // configStore: new MemoryConfigStore(),
@@ -72,6 +72,8 @@ var useOrderlyContext = () => {
   return React2.useContext(OrderlyContext);
 };
 var OrderlyProvider = OrderlyContext.Provider;
+
+// src/useConfig.ts
 function useConfig(key, defaultValue) {
   const { configStore } = React2.useContext(OrderlyContext);
   if (!configStore) {
@@ -303,7 +305,7 @@ var useWS = () => {
         networkId: configStore.get("networkId"),
         publicUrl: configStore.get("publicWsUrl"),
         privateUrl: configStore.get("privateWsUrl"),
-        onSigntureRequest: async (accountId) => {
+        onSigntureRequest: async () => {
           const signer = account9.signer;
           const timestamp = utils.getTimestamp();
           const result = await signer.signText(timestamp.toString());
@@ -705,10 +707,28 @@ var apiKeyMap = {
   staging: "dffc00e003479b86d410c448e00f2304",
   prod: "3ab9ae56ed16cc57bc2ac97ffc1098c2"
 };
+function getAmplitudeConfig(env, amplitudeConfig) {
+  if (!amplitudeConfig) {
+    return {
+      amplitudeId: apiKeyMap[env],
+      options: {
+        serverZone: "EU"
+      }
+    };
+  }
+  const { amplitudeId, serverZone } = amplitudeConfig;
+  return {
+    amplitudeId,
+    options: serverZone ? {
+      serverZone
+    } : {}
+  };
+}
 var AmplitudeTracker = class {
-  constructor(env, sdkInfo) {
+  constructor(env, amplitudeConfig, sdkInfo) {
     this._ee = core.SimpleDI.get("EE");
-    amplitude__namespace.init(apiKeyMap[env], { serverZone: "EU" });
+    const { amplitudeId, options } = getAmplitudeConfig(env, amplitudeConfig);
+    amplitude__namespace.init(amplitudeId, options);
     this.setSdkInfo(sdkInfo);
     this._bindEvents();
   }
@@ -760,15 +780,16 @@ AmplitudeTracker.instanceName = "amplitudeTracker";
 
 // src/useTrackInstance.ts
 var useTrackingInstance = () => {
-  const { configStore } = React2.useContext(OrderlyContext);
-  if (!configStore)
+  const { configStore, amplitudeConfig } = React2.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, {
+      instance = new AmplitudeTracker(env, amplitudeConfig ?? void 0, {
         brokerId,
         sdk_version: window?.__ORDERLY_VERSION__?.["@orderly.network/net"] ?? ""
       });
@@ -845,6 +866,9 @@ var DEFAULT_TICK_SIZES = {
   PERP_ETH_USDC: "0.1",
   PERP_SOL_USDC: "0.01"
 };
+var DEFAULT_SYMBOL_DEPTHS = {
+  PERP_ETH_USDC: [0.01, 0.1, 0.5, 1, 10]
+};
 var ProxyConfigStore = class {
   constructor(_originConfigStore) {
     this._originConfigStore = _originConfigStore;
@@ -1958,8 +1982,9 @@ var CalculatorService = class {
     this.ctx?.clearCache();
   }
   get windowIsVisible() {
-    if (typeof document === "undefined")
+    if (typeof document === "undefined") {
       return true;
+    }
     return document.visibilityState === "visible";
   }
 };
@@ -2443,7 +2468,7 @@ var PortfolioCalculator = class extends BaseCalculator {
       accountInfo,
       symbolsInfo,
       indexPrices,
-      tokensInfo: tokensInfo ?? []
+      tokensInfo: tokensInfo ?? types.EMPTY_LIST
     });
   }
   getPortfolio(ctx) {
@@ -2510,7 +2535,7 @@ var PortfolioCalculator = class extends BaseCalculator {
     };
   }
   update(data, scope) {
-    if (!!data) {
+    if (data) {
       useAppStore.getState().actions.batchUpdateForPortfolio({
         totalCollateral: data.totalCollateral,
         totalValue: data.totalValue,
@@ -2655,8 +2680,12 @@ var OrderbookService = class _OrderbookService {
     }
     const askMap = /* @__PURE__ */ new Map();
     const bidMap = /* @__PURE__ */ new Map();
-    rawOrderBook.asks.forEach((ask) => askMap.set(ask[0], ask[1]));
-    rawOrderBook.bids.forEach((bid) => bidMap.set(bid[0], bid[1]));
+    rawOrderBook.asks.forEach((ask) => {
+      askMap.set(ask[0], ask[1]);
+    });
+    rawOrderBook.bids.forEach((bid) => {
+      bidMap.set(bid[0], bid[1]);
+    });
     update.asks.forEach(
       (ask) => ask[1] === 0 ? askMap.delete(ask[0]) : askMap.set(ask[0], ask[1])
     );
@@ -2672,9 +2701,9 @@ var OrderbookService = class _OrderbookService {
     rawOrderBook.ts = update.ts;
   }
   applyBufferedUpdatesToRawOrderBooks(symbol) {
-    this.bufferedOrderBookUpdates[symbol]?.forEach(
-      (update) => this.applyUpdateToRawOrderBook(symbol, update)
-    );
+    this.bufferedOrderBookUpdates[symbol]?.forEach((update) => {
+      this.applyUpdateToRawOrderBook(symbol, update);
+    });
   }
   deleteBufferedOrderBookUpdates(symbol) {
     delete this.bufferedOrderBookUpdates[symbol];
@@ -2901,63 +2930,56 @@ var useTickerStream = (symbol) => {
 };
 
 // src/orderly/useOrderbookStream.ts
-var paddingFn = (len) => Array(len).fill([
-  Number.NaN,
-  Number.NaN,
-  Number.NaN,
-  Number.NaN
-]);
-var reduceItems = (depth, level, data, asks = false) => {
+var paddingFn = (len) => Array(len).fill([Number.NaN, Number.NaN, Number.NaN, Number.NaN]);
+var isNumber = (val) => {
+  return typeof val === "number" && !Number.isNaN(val);
+};
+var getPriceKey = (rawPrice, depth, isAsks) => {
+  return new utils.Decimal(rawPrice).div(depth).toDecimalPlaces(0, isAsks ? utils.Decimal.ROUND_CEIL : utils.Decimal.ROUND_FLOOR).mul(depth).toNumber();
+};
+var reduceItems = (depth, data, isAsks) => {
   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))
+    const pricesMap = /* @__PURE__ */ new Map();
+    const len = data.length;
+    for (let i = 0; i < len; i++) {
+      const [rawPrice, quantity] = data[i];
+      if (!isNumber(rawPrice) || !isNumber(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 (depth < 1 && depth > 0 && priceKey.toString().indexOf(".") !== -1) {
-        const priceStr = price.toString();
-        const index = priceStr.indexOf(".");
-        const decimal = priceStr.slice(index + 1);
-        const decimalDepth = utils.removeTrailingZeros(depth).toString().slice(2).length;
-        const decimalStr = decimal.slice(0, ramda.min(decimal.length, decimalDepth));
-        priceKey = new utils.Decimal(
-          priceStr.slice(0, index) + "." + decimalStr
-        ).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]);
+      }
+      const priceKey = getPriceKey(rawPrice, depth, isAsks);
+      const amtByRaw = new utils.Decimal(rawPrice).mul(quantity).toNumber();
+      if (pricesMap.has(priceKey)) {
+        const item = pricesMap.get(priceKey);
+        const sumQty = new utils.Decimal(item[1]).add(quantity).toNumber();
+        const sumAmtByRaw = new utils.Decimal(item[2] ?? 0).add(amtByRaw).toNumber();
+        pricesMap.set(priceKey, [priceKey, sumQty, sumAmtByRaw]);
       } else {
-        prices.set(priceKey, [priceKey, quantity]);
+        pricesMap.set(priceKey, [priceKey, quantity, amtByRaw]);
       }
     }
-    newData = Array.from(prices.values());
+    newData = Array.from(pricesMap.values());
   }
   for (let i = 0; i < newData.length; i++) {
-    const [price, quantity] = newData[i];
-    if (isNaN(price) || isNaN(quantity))
+    const [price, quantity, sumAmtByRaw] = newData[i];
+    if (!isNumber(price) || !isNumber(quantity)) {
       continue;
-    const newQuantity = new utils.Decimal(quantity).add(result.length > 0 ? result[result.length - 1][2] : 0).toNumber();
-    const newAmount = new utils.Decimal(quantity * price).add(result.length > 0 ? result[result.length - 1][3] : 0).toNumber();
+    }
+    const resLen = result.length;
+    const newQuantity = new utils.Decimal(quantity).add(resLen ? result[resLen - 1][2] : 0).toNumber();
+    const pieceAmount = isNumber(sumAmtByRaw) ? sumAmtByRaw : new utils.Decimal(quantity).mul(price).toNumber();
+    const newAmount = new utils.Decimal(pieceAmount).add(resLen ? result[resLen - 1][3] : 0).toNumber();
     result.push([price, quantity, newQuantity, newAmount]);
   }
   return result;
 };
 var reduceOrderbook = (depth, level, padding, data) => {
-  let asks = reduceItems(depth, level, data.asks, true);
-  let bids = reduceItems(depth, level, data.bids);
+  let asks = reduceItems(depth, data.asks, true);
+  let bids = reduceItems(depth, data.bids, false);
   if (asks.length !== 0 && bids.length !== 0 && asks[0][0] <= bids[0][0]) {
     if (asks.length === 1) {
       const [price, qty, newQuantity, newAmount] = asks[0];
@@ -2974,14 +2996,14 @@ var reduceOrderbook = (depth, level, padding, data) => {
         const [askPrice, askQty, newQuantity, newAmount] = asks[0];
         if (askPrice <= bidPrice) {
           asks.shift();
-          for (let index = 0; index < asks.length; index++) {
-            if (index === 0) {
-              const quantity = asks[index][1] + askQty;
-              asks[index][1] = quantity;
-              asks[index][2] = quantity;
-              asks[index][3] = Math.ceil(quantity) * asks[index][0];
+          for (let i = 0; i < asks.length; i++) {
+            if (i === 0) {
+              const quantity = new utils.Decimal(asks[i][1]).add(askQty);
+              asks[i][1] = quantity.toNumber();
+              asks[i][2] = quantity.toNumber();
+              asks[i][3] = quantity.toDecimalPlaces(0, utils.Decimal.ROUND_CEIL).mul(asks[i][0]).toNumber();
             } else {
-              asks[index][3] = asks[index][0] * asks[index][1] + asks[index - 1][3];
+              asks[i][3] = new utils.Decimal(asks[i][0]).mul(asks[i][1]).add(asks[i - 1][3]).toNumber();
             }
           }
         } else {
@@ -3000,6 +3022,7 @@ var reduceOrderbook = (depth, level, padding, data) => {
     bids
   };
 };
+var ORDERLY_ORDERBOOK_DEPTH_KEY = "orderly_orderbook_depth_key";
 var INIT_DATA = {
   asks: [],
   bids: []
@@ -3012,14 +3035,23 @@ var useOrderbookStream = (symbol, initial = INIT_DATA, options) => {
   const padding = options?.padding ?? true;
   const symbolRef = React2.useRef(symbol);
   symbolRef.current = symbol;
-  const { defaultOrderbookTickSizes: DEFAULT_TICK_SIZES2 } = React2.useContext(OrderlyContext);
+  const {
+    defaultOrderbookTickSizes: DEFAULT_TICK_SIZES2 = {},
+    defaultOrderbookSymbolDepths: DEFAULT_SYMBOL_DEPTHS2 = {}
+  } = React2.useContext(OrderlyContext);
   const [data, setData] = React2.useState(initial);
   const [isLoading, setIsLoading] = React2.useState(true);
   const config = useSymbolsInfo()[symbol];
-  const [depth, setDepth] = React2.useState();
+  const [depthObject, setDepthObject] = useLocalStorage(
+    ORDERLY_ORDERBOOK_DEPTH_KEY,
+    {}
+  );
   const prevMiddlePrice = React2.useRef(0);
+  const tick = config("quote_tick");
   const depths = React2.useMemo(() => {
-    const tick = config("quote_tick");
+    if (DEFAULT_SYMBOL_DEPTHS2[symbol]) {
+      return DEFAULT_SYMBOL_DEPTHS2[symbol];
+    }
     if (typeof tick === "undefined") {
       return [];
     }
@@ -3031,26 +3063,40 @@ var useOrderbookStream = (symbol, initial = INIT_DATA, options) => {
         base.mul(100).toNumber(),
         base.mul(1e3).toNumber()
       ];
-    } catch (e) {
+    } catch {
     }
     return [tick];
-  }, [config("quote_tick")]);
+  }, [symbol, tick]);
   React2.useEffect(() => {
+    if (depthObject[symbol]) {
+      return;
+    }
     if (DEFAULT_TICK_SIZES2[symbol]) {
-      setDepth(Number(DEFAULT_TICK_SIZES2[symbol]));
+      setDepthObject((prev) => ({
+        ...prev,
+        [symbol]: Number(DEFAULT_TICK_SIZES2[symbol])
+      }));
     } else {
-      setDepth(config("quote_tick"));
+      setDepthObject((prev) => ({
+        ...prev,
+        [symbol]: tick
+      }));
     }
-  }, [config("quote_tick"), symbol, DEFAULT_TICK_SIZES2]);
+  }, [depthObject, tick, symbol, DEFAULT_TICK_SIZES2]);
+  const onDepthChange = React2.useCallback(
+    (val) => {
+      setDepthObject((prev) => ({ ...prev, [symbol]: val }));
+    },
+    [symbol]
+  );
   const ws = useWS();
   const ticker = useTickerStream(symbol);
   const eventEmitter = useEventEmitter();
   React2.useEffect(() => {
     let needRequestFullOrderbook = true;
     setIsLoading(true);
-    let orderBookUpdateSub;
     let fullOrderBookUpdateSub;
-    orderBookUpdateSub = ws.subscribe(
+    const orderBookUpdateSub = ws.subscribe(
       {
         event: "subscribe",
         topic: `${symbol}@orderbookupdate`
@@ -3067,7 +3113,9 @@ var useOrderbookStream = (symbol, initial = INIT_DATA, options) => {
           orderbook_service_default.updateOrderbook(
             symbol2,
             { asks, bids, ts, prevTs },
-            () => needRequestFullOrderbook = true
+            () => {
+              needRequestFullOrderbook = true;
+            }
           );
           const data2 = orderbook_service_default.getRawOrderbook(symbol2);
           setData({ bids: data2.bids, asks: data2.asks });
@@ -3112,25 +3160,23 @@ var useOrderbookStream = (symbol, initial = INIT_DATA, options) => {
   const onItemClick = React2.useCallback((item) => {
     eventEmitter.emit("orderbook:item:click", item);
   }, []);
-  const onDepthChange = React2.useCallback((depth2) => {
-    setDepth(() => depth2);
-  }, []);
-  const reducedData = reduceOrderbook(depth, level, padding, {
-    asks: [...data.asks],
-    bids: [...data.bids]
+  const reducedData = reduceOrderbook(depthObject[symbol], level, padding, {
+    asks: data.asks,
+    bids: data.bids
   });
   React2.useEffect(() => {
     eventEmitter.emit("orderbook:update", reducedData);
   }, [reducedData]);
   const middlePrice = React2.useMemo(() => {
-    let asksFrist = 0, bidsFirst = 0;
+    let asksFrist = 0;
+    let bidsFirst = 0;
     if (data.asks.length > 0) {
       asksFrist = reducedData.asks?.[reducedData.asks.length - 1]?.[0];
     }
     if (data.bids.length > 0) {
       bidsFirst = data.bids[0][0];
     }
-    if (isNaN(asksFrist) || isNaN(bidsFirst) || !ticker) {
+    if (!isNumber(asksFrist) || !isNumber(bidsFirst) || !ticker) {
       return 0;
     }
     return [asksFrist, bidsFirst, ticker["24h_close"]].sort()[1];
@@ -3145,7 +3191,13 @@ var useOrderbookStream = (symbol, initial = INIT_DATA, options) => {
       markPrice,
       middlePrice: [prevMiddlePrice.current, middlePrice]
     },
-    { onDepthChange, depth, allDepths: depths, isLoading, onItemClick }
+    {
+      onDepthChange,
+      depth: depthObject[symbol],
+      allDepths: depths,
+      isLoading,
+      onItemClick
+    }
   ];
 };
 
@@ -3163,6 +3215,8 @@ var useFundingRatesStore = () => {
   const data = useAppStore((state) => state.fundingRates);
   return data;
 };
+
+// src/orderly/useMarket.ts
 var DefaultTab = { name: "Popular", id: 1 };
 var marketsKey = "markets";
 var useMarket = (type) => {
@@ -3202,12 +3256,13 @@ var useMarket = (type) => {
     const curData = getStore("favorites", []);
     const tabs = getFavoriteTabs;
     const result = [];
-    for (let index = 0; index < curData.length; index++) {
+    const len = curData.length;
+    for (let index = 0; index < len; index++) {
       const favData = curData[index];
-      var favTabs = favData.tabs.filter(
+      const favTabs = favData.tabs.filter(
         (tab) => tabs.findIndex((item) => tab.id === item.id) !== -1
       );
-      if (favTabs.length > 0) {
+      if (favTabs.length) {
         result.push({ ...favData, tabs: favTabs });
       }
     }
@@ -3231,7 +3286,7 @@ var useMarket = (type) => {
       saveTabs(tab);
       return;
     }
-    var tabs = [...favoriteTabs];
+    const tabs = [...favoriteTabs];
     const index = tabs.findIndex((item) => item.id === tab.id);
     if (operator?.add) {
       tabs.push(tab);
@@ -3374,7 +3429,7 @@ var useMarket = (type) => {
   };
   const markets = getData(type);
   return [
-    markets || [],
+    markets || types.EMPTY_LIST,
     {
       favoriteTabs,
       favorites,
@@ -3430,13 +3485,13 @@ var useIndexPricesStream = () => {
     getIndexPrice: useMemoizedFn(getIndexPrice)
   };
 };
-var generateLeverageLevers = (max3) => {
-  const min3 = 1;
+var generateLeverageLevers = (max2) => {
+  const min2 = 1;
   const parts = 5;
-  const step = (max3 - min3) / (parts - 1);
+  const step = (max2 - min2) / (parts - 1);
   const result = [];
   for (let i = 0; i < parts; i++) {
-    result.push(Math.floor(min3 + step * i));
+    result.push(Math.floor(min2 + step * i));
   }
   return result;
 };
@@ -5758,12 +5813,12 @@ var OrderValidation = class {
       value
     };
   }
-  static range(key, min3, max3) {
+  static range(key, min2, max2) {
     return {
       type: "range",
-      message: `${this.getLabel(key)} must be in the range of ${min3} to ${max3}`,
-      min: min3,
-      max: max3
+      message: `${this.getLabel(key)} must be in the range of ${min2} to ${max2}`,
+      min: min2,
+      max: max2
     };
   }
 };
@@ -6019,81 +6074,6 @@ var BBOOrderCreator = class extends BaseOrderCreator {
     });
   }
 };
-var { maxPrice, minPrice, scopePrice } = perp.order;
-var LimitOrderCreator = class extends BaseOrderCreator {
-  constructor() {
-    super(...arguments);
-    this.orderType = types.OrderType.LIMIT;
-  }
-  create(values2, config) {
-    const order = {
-      ...this.baseOrder(values2),
-      order_price: values2.order_price
-    };
-    this.totalToQuantity(order, config);
-    return ramda.pick(
-      [
-        "symbol",
-        "order_price",
-        "order_quantity",
-        "visible_quantity",
-        "reduce_only",
-        "side",
-        "order_type",
-        "algo_type",
-        "child_orders"
-      ],
-      order
-    );
-  }
-  validate(values2, config) {
-    return this.baseValidate(values2, config).then((errors) => {
-      const { order_price, side } = values2;
-      if (!order_price) {
-        errors.order_price = OrderValidation.required("order_price");
-      } else {
-        const price = new utils.Decimal(order_price);
-        const { symbol } = config;
-        const { price_range, price_scope, quote_max, quote_min } = symbol;
-        const maxPriceNumber = maxPrice(config.markPrice, price_range);
-        const minPriceNumber = minPrice(config.markPrice, price_range);
-        const scopePriceNumber = scopePrice(
-          config.markPrice,
-          price_scope,
-          side
-        );
-        const priceRange = side === "BUY" ? {
-          min: scopePriceNumber,
-          max: maxPriceNumber
-        } : {
-          min: minPriceNumber,
-          max: scopePriceNumber
-        };
-        if (price.gt(quote_max)) {
-          errors.order_price = OrderValidation.max("order_price", quote_max);
-        } else {
-          if (price.gt(priceRange?.max)) {
-            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 = OrderValidation.min("order_price", quote_min);
-        } else {
-          if (price.lt(priceRange?.min)) {
-            errors.order_price = OrderValidation.min(
-              "order_price",
-              new utils.Decimal(priceRange.min).todp(symbol.quote_dp).toString()
-            );
-          }
-        }
-      }
-      return errors;
-    });
-  }
-};
 function getOrderPrice(order, askAndBid) {
   const orderPrice = Number(order.order_price);
   if (order.order_type === types.OrderType.MARKET || order.order_type === types.OrderType.STOP_MARKET) {
@@ -6326,6 +6306,81 @@ async function bracketOrderValidator(values2, config) {
   }
   return Object.keys(result).length > 0 ? result : null;
 }
+var { maxPrice, minPrice, scopePrice } = perp.order;
+var LimitOrderCreator = class extends BaseOrderCreator {
+  constructor() {
+    super(...arguments);
+    this.orderType = types.OrderType.LIMIT;
+  }
+  create(values2, config) {
+    const order = {
+      ...this.baseOrder(values2),
+      order_price: values2.order_price
+    };
+    this.totalToQuantity(order, config);
+    return ramda.pick(
+      [
+        "symbol",
+        "order_price",
+        "order_quantity",
+        "visible_quantity",
+        "reduce_only",
+        "side",
+        "order_type",
+        "algo_type",
+        "child_orders"
+      ],
+      order
+    );
+  }
+  validate(values2, config) {
+    return this.baseValidate(values2, config).then((errors) => {
+      const { order_price, side } = values2;
+      if (!order_price) {
+        errors.order_price = OrderValidation.required("order_price");
+      } else {
+        const price = new utils.Decimal(order_price);
+        const { symbol } = config;
+        const { price_range, price_scope, quote_max, quote_min } = symbol;
+        const maxPriceNumber = maxPrice(config.markPrice, price_range);
+        const minPriceNumber = minPrice(config.markPrice, price_range);
+        const scopePriceNumber = scopePrice(
+          config.markPrice,
+          price_scope,
+          side
+        );
+        const priceRange = side === "BUY" ? {
+          min: scopePriceNumber,
+          max: maxPriceNumber
+        } : {
+          min: minPriceNumber,
+          max: scopePriceNumber
+        };
+        if (price.gt(quote_max)) {
+          errors.order_price = OrderValidation.max("order_price", quote_max);
+        } else {
+          if (price.gt(priceRange?.max)) {
+            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 = OrderValidation.min("order_price", quote_min);
+        } else {
+          if (price.lt(priceRange?.min)) {
+            errors.order_price = OrderValidation.min(
+              "order_price",
+              new utils.Decimal(priceRange.min).todp(symbol.quote_dp).toString()
+            );
+          }
+        }
+      }
+      return errors;
+    });
+  }
+};
 
 // src/services/orderCreator/bracketLimitOrderCreator.ts
 var BracketLimitOrderCreator = class extends LimitOrderCreator {
@@ -6469,7 +6524,7 @@ function calcScaledOrderWeights(inputs) {
   }
   const sumWeights = weights.reduce((acc, cur) => acc.plus(cur), utils.zero);
   const minWeight = weights.reduce(
-    (min3, current) => current.lt(min3) ? current : min3,
+    (min2, current) => current.lt(min2) ? current : min2,
     weights?.[0]
   );
   return {
@@ -6619,7 +6674,7 @@ function calcScaledOrderMinTotalAmountByMinNotional(order, symbolInfo, askAndBid
     return new utils.Decimal(min_notional).mul(sumWeights).div(new utils.Decimal(weights[i]).mul(orderPrice));
   });
   const max_minQty = minQtys.reduce(
-    (max3, current) => current.gt(max3) ? current : max3,
+    (max2, current) => current.gt(max2) ? current : max2,
     minQtys?.[0]
   );
   return max_minQty.todp(base_dp, utils.Decimal.ROUND_UP).toNumber();
@@ -7327,6 +7382,152 @@ var OrderFactory = class {
     }
   }
 };
+
+// src/next/useOrderEntry/helper.ts
+var getCreateOrderUrl = (order) => {
+  const isAlgoOrder = order?.order_type === types.OrderType.STOP_LIMIT || order?.order_type === types.OrderType.STOP_MARKET || order?.order_type === types.OrderType.CLOSE_POSITION || order.algo_type && order.algo_type === types.AlgoOrderRootType.BRACKET || isBracketOrder(order);
+  if (order.order_type === types.OrderType.SCALED) {
+    return "/v1/batch-order";
+  }
+  return isAlgoOrder ? "/v1/algo/order" : "/v1/order";
+};
+var getOrderCreator = (order) => {
+  let type;
+  if (isBracketOrder(order)) {
+    type = `${types.AlgoOrderRootType.BRACKET}:${order.order_type}`;
+  } else if (order.order_type === types.OrderType.LIMIT) {
+    type = order.order_type_ext || order.order_type;
+  } else {
+    type = order.order_type;
+  }
+  return OrderFactory.create(type);
+};
+var tpslFields = [
+  "tp_trigger_price",
+  "sl_trigger_price",
+  "tp_pnl",
+  "sl_pnl",
+  "tp_offset",
+  "sl_offset",
+  "tp_offset_percentage",
+  "sl_offset_percentage"
+];
+var isBracketOrder = (order) => {
+  if (order.sl_enable || order.tp_enable) {
+    return true;
+  }
+  return !!order.tp_trigger_price || !!order.sl_trigger_price;
+};
+var hasTPSL = (order) => {
+  return tpslFields.some((field) => !!order[field]);
+};
+var getPriceAndQty = (order, symbolInfo, askAndBid) => {
+  let quantity = Number(order.order_quantity);
+  const orderPrice = Number(order.order_price);
+  if (isNaN(quantity) || quantity <= 0) {
+    return null;
+  }
+  if (askAndBid.length === 0) {
+    return null;
+  }
+  if ((order.order_type === types.OrderType.LIMIT || order.order_type === types.OrderType.STOP_LIMIT) && isNaN(orderPrice)) {
+    return null;
+  }
+  let price;
+  if (order.order_type === types.OrderType.SCALED) {
+    price = calcScaledOrderAvgPrice(order, symbolInfo, askAndBid);
+    const orders = calcScaledOrderBatchBody(order, symbolInfo);
+    const sumQtys = orders.reduce((acc, order2) => {
+      return acc.plus(new utils.Decimal(order2.order_quantity));
+    }, utils.zero);
+    quantity = sumQtys.todp(symbolInfo.base_dp).toNumber();
+    if (!quantity || isNaN(quantity)) {
+      return null;
+    }
+  } else {
+    price = getOrderPrice(order, askAndBid);
+  }
+  if (!price || isNaN(price)) {
+    return null;
+  }
+  if (order.side === types.OrderSide.SELL) {
+    quantity = -quantity;
+  }
+  return { price, quantity };
+};
+var calcEstLiqPrice = (order, askAndBid, inputs) => {
+  const { symbolInfo } = inputs;
+  const result = getPriceAndQty(order, symbolInfo, askAndBid);
+  if (!result)
+    return null;
+  const { price, quantity } = result;
+  if (!price || !quantity)
+    return null;
+  const {
+    symbol,
+    imr_factor,
+    markPrice,
+    totalCollateral,
+    futures_taker_fee_rate,
+    positions: positions3
+  } = inputs;
+  const orderFee = perp.order.orderFee({
+    qty: quantity,
+    price,
+    futuresTakeFeeRate: Number(futures_taker_fee_rate) / 1e4
+  });
+  const liqPrice = perp.order.estLiqPrice({
+    markPrice,
+    baseIMR: symbolInfo.base_imr,
+    baseMMR: symbolInfo.base_mmr,
+    totalCollateral,
+    positions: positions3 == null ? [] : positions3,
+    IMR_Factor: imr_factor,
+    orderFee,
+    newOrder: {
+      qty: quantity,
+      price,
+      symbol
+    }
+  });
+  if (liqPrice <= 0)
+    return null;
+  return liqPrice;
+};
+var calcEstLeverage = (order, askAndBid, inputs) => {
+  const { totalCollateral, positions: positions3, symbol, symbolInfo } = inputs;
+  const result = getPriceAndQty(order, symbolInfo, askAndBid);
+  if (!result)
+    return null;
+  const { price, quantity } = result;
+  if (!price || !quantity)
+    return null;
+  return perp.order.estLeverage({
+    totalCollateral,
+    positions: positions3,
+    newOrder: {
+      symbol,
+      qty: result.quantity,
+      price: result.price
+    }
+  });
+};
+function isBBOOrder(options) {
+  const { order_type, order_type_ext } = options;
+  return order_type === types.OrderType.LIMIT && [types.OrderType.ASK, types.OrderType.BID].includes(order_type_ext);
+}
+function appendOrderMetadata(order, orderMetadata) {
+  if (Array.isArray(order)) {
+    return order.map((item) => ({
+      ...item,
+      ...typeof orderMetadata === "function" ? orderMetadata(item) : orderMetadata
+    }));
+  }
+  return {
+    ...order,
+    ...typeof orderMetadata === "function" ? orderMetadata(order) : orderMetadata
+  };
+}
 function useSubAccountQuery(query, options) {
   const { formatter, accountId, ...swrOptions } = options || {};
   const { state, account: account9 } = useAccount();
@@ -8166,6 +8367,13 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
   const [doUpdateOrder, { isMutating: isUpdateMutating }] = useSubAccountMutation("/v1/algo/order", "PUT");
   const [doDeleteOrder] = useMutation("/v1/algo/order", "DELETE");
   const [errors, setErrors] = React2.useState(null);
+  const [meta, setMeta] = React2.useState({
+    dirty: {},
+    submitted: false,
+    validated: false,
+    errors: null
+  });
+  const { orderMetadata } = useOrderlyContext();
   React2.useEffect(() => {
     if (!isEditing || !options?.defaultOrder)
       return;
@@ -8204,6 +8412,14 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
           symbol: symbolInfo
         }
       );
+      const newValueAll = {
+        ...prev,
+        ...newValue,
+        ignoreValidate: options2?.ignoreValidate
+      };
+      interactiveValidate(
+        newValueAll
+      );
       return {
         ...prev,
         ...newValue,
@@ -8244,19 +8460,28 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
     maxQty: Math.abs(position.position_qty),
     markPrice
   };
-  React2.useEffect(() => {
-    requestAnimationFrame(() => {
-      if (order.ignoreValidate)
-        return;
-      if (!order.quantity) {
-        return;
+  const interactiveValidate = (order2) => {
+    validateFunc(order2).then((errors2) => {
+      const keys = Object.keys(errors2 ?? {});
+      if (keys.length > 0) {
+        setMeta(
+          immer$1.produce((draft) => {
+            draft.errors = errors2;
+          })
+        );
+      } else {
+        setMeta(
+          immer$1.produce((draft) => {
+            draft.errors = null;
+          })
+        );
       }
-      const orderCreator = getOrderCreator2();
-      orderCreator.validate(order, valueConfig).then((errors2) => {
-        setErrors(errors2);
-      });
     });
-  }, [order, valueConfig.markPrice, order.quantity]);
+  };
+  const validateFunc = async (order2) => {
+    const creator = getOrderCreator2();
+    return creator.validate(order2, valueConfig);
+  };
   const setValues = (values2) => {
     const keys = Object.keys(values2);
     keys.forEach((key) => {
@@ -8274,6 +8499,21 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
         valueConfig
       ).then((errors2) => {
         if (errors2) {
+          const keys = Object.keys(errors2);
+          if (keys.length > 0) {
+            setMeta(
+              immer$1.produce((draft) => {
+                draft.errors = errors2;
+              })
+            );
+            if (!meta.validated) {
+              setMeta(
+                immer$1.produce((draft) => {
+                  draft.validated = true;
+                })
+              );
+            }
+          }
           setErrors(errors2);
           return reject(errors2);
         }
@@ -8327,7 +8567,8 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
     orderBody.child_orders = orderBody.child_orders.filter(
       (order2) => order2.is_activated
     );
-    return doCreateOrder(orderBody, {}, params);
+    const body = appendOrderMetadata(orderBody, orderMetadata);
+    return doCreateOrder(body, {}, params);
   };
   const deleteOrder = (orderId, symbol) => {
     return doDeleteOrder(null, {
@@ -8373,6 +8614,7 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
       // createPositionTPSL: submit,
       // createTPSL: submit,
       validate,
+      metaState: meta,
       errors,
       isCreateMutating,
       isUpdateMutating
@@ -9150,7 +9392,12 @@ var OrderlyConfigProvider = (props) => {
     enableSwapDeposit = false,
     chainTransformer,
     dataAdapter,
-    notification
+    notification,
+    amplitudeConfig,
+    orderbookDefaultTickSizes,
+    orderbookDefaultSymbolDepths,
+    children,
+    orderMetadata
   } = props;
   if (typeof configStore !== "undefined" && !configStore.get("brokerId")) {
     throw new types.SDKError(
@@ -9164,7 +9411,11 @@ var OrderlyConfigProvider = (props) => {
   }
   const innerConfigStore = React2.useMemo(() => {
     return new ProxyConfigStore(
-      configStore || new ExtendedConfigStore({ brokerId, brokerName, networkId })
+      configStore || new ExtendedConfigStore({
+        brokerId,
+        brokerName,
+        networkId
+      })
     );
   }, [configStore, brokerId, brokerName, networkId]);
   const innerKeyStore = React2.useMemo(() => {
@@ -9177,8 +9428,11 @@ var OrderlyConfigProvider = (props) => {
     ];
   }, [walletAdapters]);
   const defaultOrderbookTickSizes = React2.useMemo(() => {
-    return props.orderbookDefaultTickSizes || DEFAULT_TICK_SIZES;
-  }, [props.orderbookDefaultTickSizes]);
+    return orderbookDefaultTickSizes || DEFAULT_TICK_SIZES;
+  }, [orderbookDefaultTickSizes]);
+  const defaultOrderbookSymbolDepths = React2.useMemo(() => {
+    return orderbookDefaultSymbolDepths || DEFAULT_SYMBOL_DEPTHS;
+  }, [orderbookDefaultSymbolDepths]);
   React2.useLayoutEffect(() => {
     let account10 = core.SimpleDI.get(core.Account.instanceName);
     if (!account10) {
@@ -9200,7 +9454,7 @@ var OrderlyConfigProvider = (props) => {
       return chainFilter(innerConfigStore);
     }
     return chainFilter;
-  }, [props.chainFilter, innerConfigStore]);
+  }, [chainFilter, innerConfigStore]);
   const memoizedValue = React2.useMemo(() => {
     return {
       configStore: innerConfigStore,
@@ -9211,9 +9465,12 @@ var OrderlyConfigProvider = (props) => {
       customChains,
       enableSwapDeposit,
       defaultOrderbookTickSizes,
+      defaultOrderbookSymbolDepths,
       chainTransformer,
       dataAdapter,
-      notification
+      notification,
+      amplitudeConfig,
+      orderMetadata
     };
   }, [
     innerConfigStore,
@@ -9224,14 +9481,17 @@ var OrderlyConfigProvider = (props) => {
     customChains,
     enableSwapDeposit,
     defaultOrderbookTickSizes,
+    defaultOrderbookSymbolDepths,
     dataAdapter,
     notification,
-    chainTransformer
+    chainTransformer,
+    amplitudeConfig,
+    orderMetadata
   ]);
   if (!account9) {
     return null;
   }
-  return /* @__PURE__ */ jsxRuntime.jsx(OrderlyProvider, { value: memoizedValue, children: /* @__PURE__ */ jsxRuntime.jsx(StatusProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(DataCenterProvider, { children: props.children }) }) });
+  return /* @__PURE__ */ jsxRuntime.jsx(OrderlyProvider, { value: memoizedValue, children: /* @__PURE__ */ jsxRuntime.jsx(StatusProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(DataCenterProvider, { children }) }) });
 };
 var needNumberOnlyFields = [
   "order_quantity",
@@ -16187,138 +16447,6 @@ function getQueryParamsFromObject(obj) {
   }
   return queryParams.toString();
 }
-var getCreateOrderUrl = (order) => {
-  const isAlgoOrder = order?.order_type === types.OrderType.STOP_LIMIT || order?.order_type === types.OrderType.STOP_MARKET || order?.order_type === types.OrderType.CLOSE_POSITION || order.algo_type && order.algo_type === types.AlgoOrderRootType.BRACKET || isBracketOrder(order);
-  if (order.order_type === types.OrderType.SCALED) {
-    return "/v1/batch-order";
-  }
-  return isAlgoOrder ? "/v1/algo/order" : "/v1/order";
-};
-var getOrderCreator = (order) => {
-  let type;
-  if (isBracketOrder(order)) {
-    type = `${types.AlgoOrderRootType.BRACKET}:${order.order_type}`;
-  } else if (order.order_type === types.OrderType.LIMIT) {
-    type = order.order_type_ext || order.order_type;
-  } else {
-    type = order.order_type;
-  }
-  return OrderFactory.create(type);
-};
-var tpslFields = [
-  "tp_trigger_price",
-  "sl_trigger_price",
-  "tp_pnl",
-  "sl_pnl",
-  "tp_offset",
-  "sl_offset",
-  "tp_offset_percentage",
-  "sl_offset_percentage"
-];
-var isBracketOrder = (order) => {
-  if (order.sl_enable || order.tp_enable) {
-    return true;
-  }
-  return !!order.tp_trigger_price || !!order.sl_trigger_price;
-};
-var hasTPSL = (order) => {
-  return tpslFields.some((field) => !!order[field]);
-};
-var getPriceAndQty = (order, symbolInfo, askAndBid) => {
-  let quantity = Number(order.order_quantity);
-  const orderPrice = Number(order.order_price);
-  if (isNaN(quantity) || quantity <= 0) {
-    return null;
-  }
-  if (askAndBid.length === 0) {
-    return null;
-  }
-  if ((order.order_type === types.OrderType.LIMIT || order.order_type === types.OrderType.STOP_LIMIT) && isNaN(orderPrice)) {
-    return null;
-  }
-  let price;
-  if (order.order_type === types.OrderType.SCALED) {
-    price = calcScaledOrderAvgPrice(order, symbolInfo, askAndBid);
-    const orders = calcScaledOrderBatchBody(order, symbolInfo);
-    const sumQtys = orders.reduce((acc, order2) => {
-      return acc.plus(new utils.Decimal(order2.order_quantity));
-    }, utils.zero);
-    quantity = sumQtys.todp(symbolInfo.base_dp).toNumber();
-    if (!quantity || isNaN(quantity)) {
-      return null;
-    }
-  } else {
-    price = getOrderPrice(order, askAndBid);
-  }
-  if (!price || isNaN(price)) {
-    return null;
-  }
-  if (order.side === types.OrderSide.SELL) {
-    quantity = -quantity;
-  }
-  return { price, quantity };
-};
-var calcEstLiqPrice = (order, askAndBid, inputs) => {
-  const { symbolInfo } = inputs;
-  const result = getPriceAndQty(order, symbolInfo, askAndBid);
-  if (!result)
-    return null;
-  const { price, quantity } = result;
-  if (!price || !quantity)
-    return null;
-  const {
-    symbol,
-    imr_factor,
-    markPrice,
-    totalCollateral,
-    futures_taker_fee_rate,
-    positions: positions3
-  } = inputs;
-  const orderFee = perp.order.orderFee({
-    qty: quantity,
-    price,
-    futuresTakeFeeRate: Number(futures_taker_fee_rate) / 1e4
-  });
-  const liqPrice = perp.order.estLiqPrice({
-    markPrice,
-    baseIMR: symbolInfo.base_imr,
-    baseMMR: symbolInfo.base_mmr,
-    totalCollateral,
-    positions: positions3 == null ? [] : positions3,
-    IMR_Factor: imr_factor,
-    orderFee,
-    newOrder: {
-      qty: quantity,
-      price,
-      symbol
-    }
-  });
-  if (liqPrice <= 0)
-    return null;
-  return liqPrice;
-};
-var calcEstLeverage = (order, askAndBid, inputs) => {
-  const { totalCollateral, positions: positions3, symbol, symbolInfo } = inputs;
-  const result = getPriceAndQty(order, symbolInfo, askAndBid);
-  if (!result)
-    return null;
-  const { price, quantity } = result;
-  if (!price || !quantity)
-    return null;
-  return perp.order.estLeverage({
-    totalCollateral,
-    positions: positions3,
-    newOrder: {
-      symbol,
-      qty: result.quantity,
-      price: result.price
-    }
-  });
-};
-function isBBOOrder(options) {
-  const { order_type, order_type_ext } = options;
-  return order_type === types.OrderType.LIMIT && [types.OrderType.ASK, types.OrderType.BID].includes(order_type_ext);
-}
 var initialOrderState = {
   order_price: "",
   order_quantity: "",
@@ -16631,6 +16759,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
   const positions3 = usePositions();
   const symbolInfo = symbolConfig[symbol]();
   const markPrice = actions.getMarkPriceBySymbol(symbol);
+  const { orderMetadata } = useOrderlyContext();
   const {
     formattedOrder,
     setValue: setValueInternal,
@@ -16946,7 +17075,9 @@ var useOrderEntry2 = (symbol, options = {}) => {
     }
     const order = generateOrder(creator, prepareData());
     const isScaledOrder = order.order_type === types.OrderType.SCALED;
-    const params = isScaledOrder ? { orders: order.orders } : order;
+    const params = isScaledOrder ? {
+      orders: appendOrderMetadata(order.orders, orderMetadata)
+    } : appendOrderMetadata(order, orderMetadata);
     const result = await doCreateOrder(params);
     if (result.success) {
       let trackParams = {
@@ -17247,6 +17378,7 @@ var usePositionClose = (options) => {
   const symbolsInfo = useSymbolsInfo();
   const { data: markPrices } = useMarkPricesStream();
   const markPricesRef = React2.useRef(markPrices);
+  const { orderMetadata } = useOrderlyContext();
   React2.useEffect(() => {
     markPricesRef.current = markPrices;
   }, [markPrices]);
@@ -17315,7 +17447,8 @@ var usePositionClose = (options) => {
     if (Object.keys(errors2).length > 0) {
       throw errors2;
     }
-    return doCreateOrder(closeOrderData).then((res) => {
+    const body = appendOrderMetadata(closeOrderData, orderMetadata);
+    return doCreateOrder(body).then((res) => {
       if (res.success) {
         return res;
       }
@@ -17323,7 +17456,7 @@ var usePositionClose = (options) => {
     }).catch((err) => {
       throw err;
     });
-  }, [validate, doCreateOrder, closeOrderData]);
+  }, [validate, doCreateOrder, closeOrderData, orderMetadata]);
   return {
     submit,
     isMutating,
@@ -17359,6 +17492,7 @@ exports.ExtendedConfigStore = ExtendedConfigStore;
 exports.MaintenanceStatus = MaintenanceStatus;
 exports.MarketsStorageKey = MarketsStorageKey;
 exports.MarketsType = MarketsType;
+exports.ORDERLY_ORDERBOOK_DEPTH_KEY = ORDERLY_ORDERBOOK_DEPTH_KEY;
 exports.OrderlyConfigProvider = OrderlyConfigProvider;
 exports.OrderlyContext = OrderlyContext;
 exports.OrderlyProvider = OrderlyProvider;
@@ -17373,6 +17507,7 @@ exports.findPositionTPSLFromOrders = findPositionTPSLFromOrders;
 exports.findTPSLFromOrder = findTPSLFromOrder;
 exports.findTPSLOrderPriceFromOrder = findTPSLOrderPriceFromOrder;
 exports.getMinNotional = getMinNotional;
+exports.getPriceKey = getPriceKey;
 exports.parseJSON = parseJSON;
 exports.useAccount = useAccount;
 exports.useAccountInfo = useAccountInfo2;