@orderly.network/hooks 2.3.2 → 2.4.0

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.3.2";
+  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.4.0";
 }
-var version_default = "2.3.2";
+var version_default = "2.4.0";
 var fetcher = (url, init2 = {}, queryOptions) => net.get(url, init2, queryOptions?.formatter);
 var OrderlyContext = React.createContext({
   // configStore: new MemoryConfigStore(),
@@ -268,7 +268,8 @@ var useTrack = () => {
           page_title: title,
           page_url: url,
           page_domain: origin,
-          user_agent: userAgent
+          user_agent: userAgent,
+          sdk_version: window?.__ORDERLY_VERSION__?.["@orderly.network/net"] ?? ""
         });
         if (eventName === types.TrackerEventName.placeOrderSuccess) {
           Object.assign(params, {
@@ -4200,7 +4201,7 @@ function fillChainsInfo(chains, filter, chainInfos) {
   return _chains;
 }
 function filterAndUpdateChains(chains, chainInfos, filter, isTestNet) {
-  const filterChains = [];
+  const chainsMap = /* @__PURE__ */ new Map();
   chains.forEach((chain) => {
     const _chain = { ...chain };
     const networkInfo = chainInfos?.find(
@@ -4225,10 +4226,10 @@ function filterAndUpdateChains(chains, chainInfos, filter, isTestNet) {
         return;
     }
     if (networkInfo) {
-      filterChains.push(_chain);
+      chainsMap.set(chain.network_infos.chain_id, _chain);
     }
   });
-  return filterChains;
+  return Array.from(chainsMap.values());
 }
 function filterByAllowedChains(chains, allowedChains) {
   if (!allowedChains) {
@@ -4912,12 +4913,11 @@ var useSymbolPriceRange = (symbol, side, price) => {
 };
 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) {
+  if (price && qty && min_notional) {
     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);
+      const calcMinNotional = new utils.Decimal(price).mul(new utils.Decimal(qty));
+      if (calcMinNotional.lt(min_notional)) {
+        let minQty = new utils.Decimal(min_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)
@@ -4975,6 +4975,14 @@ var OrderValidation = class {
         return "TP price";
       case "sl_trigger_price":
         return "SL price";
+      case "max_price":
+        return "Upper price";
+      case "min_price":
+        return "Lower price";
+      case "total_orders":
+        return "Total orders";
+      case "skew":
+        return "Skew";
       default:
         return key;
     }
@@ -4999,6 +5007,14 @@ var OrderValidation = class {
       value
     };
   }
+  static range(key, min3, max3) {
+    return {
+      type: "range",
+      message: `${this.getLabel(key)} must be in the range of ${min3} to ${max3}`,
+      min: min3,
+      max: max3
+    };
+  }
 };
 
 // src/services/orderCreator/baseCreator.ts
@@ -5201,33 +5217,33 @@ var BaseOrderCreator = class {
   }
 };
 
-// src/services/orderCreator/marketOrderCreator.ts
-var MarketOrderCreator = class extends BaseOrderCreator {
+// src/services/orderCreator/bboOrderCreator.ts
+var BBOOrderCreator = class extends BaseOrderCreator {
+  constructor() {
+    super(...arguments);
+    this.orderType = types.OrderType.LIMIT;
+  }
   create(values2) {
-    const data = this.baseOrder(values2);
-    delete data["order_price"];
-    delete data["total"];
-    delete data["trigger_price"];
-    delete data["isStopOrder"];
-    return {
-      ...data
+    const order = {
+      ...this.baseOrder(values2),
+      level: values2.level
     };
+    return ramda.pick(
+      [
+        "symbol",
+        "order_quantity",
+        "visible_quantity",
+        "reduce_only",
+        "side",
+        "order_type",
+        "level"
+      ],
+      order
+    );
   }
-  validate(values2, configs) {
-    return this.baseValidate(values2, configs).then((result) => {
-      const slippage = Number(values2.slippage);
-      const estSlippage = Number.isNaN(configs.estSlippage) ? 0 : Number(configs.estSlippage) * 100;
-      if (!isNaN(slippage) && estSlippage > slippage) {
-        return {
-          ...result,
-          slippage: {
-            type: "max",
-            message: "Estimated slippage exceeds your maximum allowed slippage.",
-            value: estSlippage
-          }
-        };
-      }
-      return result;
+  async validate(values2, configs) {
+    return this.baseValidate(values2, configs).then((errors) => {
+      return errors;
     });
   }
 };
@@ -5306,124 +5322,791 @@ var LimitOrderCreator = class extends BaseOrderCreator {
     });
   }
 };
-var { maxPrice: maxPrice2, minPrice: minPrice2, scopePrice: scopePrice2 } = perp.order;
-var StopLimitOrderCreator = class extends BaseOrderCreator {
-  constructor() {
-    super(...arguments);
-    this.orderType = types.OrderType.STOP_LIMIT;
+async function bracketOrderValidator(values2, config) {
+  const result = /* @__PURE__ */ Object.create(null);
+  await Promise.resolve();
+  const { tp_trigger_price, sl_trigger_price, side } = values2;
+  const qty = Number(values2.quantity);
+  const maxQty = config.maxQty;
+  const type = values2.order_type;
+  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 = OrderValidation.max("quantity", config.maxQty);
   }
-  create(values2, config) {
-    this.totalToQuantity(values2, config);
-    const order = {
-      ...this.baseOrder(values2),
-      trigger_price: values2.trigger_price,
-      algo_type: types.AlgoOrderRootType.STOP,
-      type: types.OrderType.LIMIT,
-      quantity: values2["order_quantity"],
-      price: values2["order_price"],
-      trigger_price_type: types.TriggerPriceType.MARK_PRICE
-    };
-    return ramda.pick(
-      [
-        "symbol",
-        "trigger_price",
-        "algo_type",
-        "type",
-        "quantity",
-        "price",
-        "trigger_price_type",
-        "side",
-        "reduce_only",
-        "visible_quantity"
-      ],
-      order
-    );
+  if (Number(tp_trigger_price) < 0) {
+    result.tp_trigger_price = OrderValidation.min("tp_trigger_price", 0);
   }
-  validate(values2, config) {
-    return this.baseValidate(values2, config).then((errors) => {
-      const { order_price, trigger_price, side } = values2;
-      const { symbol } = config;
-      const { price_range, price_scope, quote_max, quote_min } = symbol;
-      if (!trigger_price) {
-        errors.trigger_price = OrderValidation.required("trigger_price");
-      }
-      if (!order_price) {
-        errors.order_price = OrderValidation.required("order_price");
-      }
-      if (trigger_price > quote_max) {
-        errors.trigger_price = OrderValidation.max("trigger_price", quote_max);
-      } else if (trigger_price < quote_min) {
-        errors.trigger_price = OrderValidation.min("trigger_price", quote_min);
-      } else {
-        if (trigger_price && order_price) {
-          const price = new utils.Decimal(order_price);
-          const maxPriceNumber = maxPrice2(trigger_price, price_range);
-          const minPriceNumber = minPrice2(trigger_price, price_range);
-          const scropePriceNumbere = scopePrice2(
-            trigger_price,
-            price_scope,
-            side
-          );
-          const priceRange = side === "BUY" ? {
-            min: scropePriceNumbere,
-            max: maxPriceNumber
-          } : {
-            min: minPriceNumber,
-            max: scropePriceNumbere
-          };
-          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;
-    });
+  if (Number(sl_trigger_price) < 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 = OrderValidation.min(
+        "sl_trigger_price",
+        slTriggerPriceScope
+      );
+    }
+    if (!!tp_trigger_price && Number(tp_trigger_price) <= 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 = OrderValidation.max(
+        "tp_trigger_price",
+        quote_max
+      );
+    }
+    if (!!sl_trigger_price && Number(sl_trigger_price) < 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 = OrderValidation.max(
+        "sl_trigger_price",
+        slTriggerPriceScope
+      );
+    }
+    if (!!tp_trigger_price && Number(tp_trigger_price) >= 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 = OrderValidation.max(
+        "tp_trigger_price",
+        quote_max
+      );
+    }
+    if (!!sl_trigger_price && Number(sl_trigger_price) < quote_min) {
+      result.sl_trigger_price = OrderValidation.min(
+        "sl_trigger_price",
+        quote_min
+      );
+    }
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
 
-// src/services/orderCreator/generalCreator.ts
-var GeneralOrderCreator = class extends BaseOrderCreator {
-  create(data) {
+// src/services/orderCreator/bracketLimitOrderCreator.ts
+var BracketLimitOrderCreator = class extends LimitOrderCreator {
+  // orderType: OrderType;
+  create(values2, config) {
+    const order = super.create(values2, config);
     return {
-      ...this.baseOrder(data),
-      order_price: data.order_price,
-      order_quantity: data.order_quantity
+      ...order,
+      quantity: order.order_quantity,
+      type: order.order_type,
+      price: order.order_price
     };
   }
-  validate(values2, configs) {
-    return super.baseValidate(values2, configs);
+  async validate(values2, config) {
+    const value = await super.validate(values2, config);
+    const bracketData = await bracketOrderValidator(values2, config);
+    return { ...value, ...bracketData };
   }
 };
-var StopMarketOrderCreator = class extends BaseOrderCreator {
+
+// src/services/orderCreator/marketOrderCreator.ts
+var MarketOrderCreator = class extends BaseOrderCreator {
   create(values2) {
-    const order = {
-      ...this.baseOrder(values2),
-      // order_price: values.order_price,
-      trigger_price: values2.trigger_price,
-      algo_type: types.AlgoOrderRootType.STOP,
-      type: types.OrderType.MARKET,
-      quantity: values2["order_quantity"],
-      // price: values["order_price"],
-      trigger_price_type: types.TriggerPriceType.MARK_PRICE
+    const data = this.baseOrder(values2);
+    delete data["order_price"];
+    delete data["total"];
+    delete data["trigger_price"];
+    delete data["isStopOrder"];
+    return {
+      ...data
     };
-    return ramda.pick(
+  }
+  validate(values2, configs) {
+    return this.baseValidate(values2, configs).then((result) => {
+      const slippage = Number(values2.slippage);
+      const estSlippage = Number.isNaN(configs.estSlippage) ? 0 : Number(configs.estSlippage) * 100;
+      if (!isNaN(slippage) && estSlippage > slippage) {
+        return {
+          ...result,
+          slippage: {
+            type: "max",
+            message: "Estimated slippage exceeds your maximum allowed slippage.",
+            value: estSlippage
+          }
+        };
+      }
+      return result;
+    });
+  }
+};
+
+// src/services/orderCreator/bracketMarketOrderCreator.ts
+var BracketMarketOrderCreator = class extends MarketOrderCreator {
+  constructor() {
+    super(...arguments);
+    this.orderType = types.OrderType.MARKET;
+  }
+  create(values2) {
+    const order = super.create(values2);
+    return {
+      ...order,
+      quantity: order.order_quantity,
+      type: order.order_type,
+      price: order.order_price
+    };
+  }
+  async validate(values2, config) {
+    const value = await super.validate(values2, config);
+    const bracketData = await bracketOrderValidator(values2, config);
+    return { ...value, ...bracketData };
+  }
+};
+
+// src/services/orderCreator/fokCreator.ts
+var FOKOrderCreator = class extends LimitOrderCreator {
+};
+
+// src/services/orderCreator/generalCreator.ts
+var GeneralOrderCreator = class extends BaseOrderCreator {
+  create(data) {
+    return {
+      ...this.baseOrder(data),
+      order_price: data.order_price,
+      order_quantity: data.order_quantity
+    };
+  }
+  validate(values2, configs) {
+    return super.baseValidate(values2, configs);
+  }
+};
+
+// src/services/orderCreator/iocCreator.ts
+var IOCOrderCreator = class extends LimitOrderCreator {
+};
+
+// src/services/orderCreator/postOnlyCreator.ts
+var PostOnlyOrderCreator = class extends LimitOrderCreator {
+};
+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) => {
+  return !!order.tp_trigger_price || !!order.sl_trigger_price;
+};
+var hasTPSL = (order) => {
+  return tpslFields.some((field) => !!order[field]);
+};
+function getOrderPrice(order, askAndBid) {
+  const orderPrice = Number(order.order_price);
+  if (order.order_type === types.OrderType.MARKET || order.order_type === types.OrderType.STOP_MARKET) {
+    if (order.side === types.OrderSide.BUY) {
+      return askAndBid[0];
+    } else {
+      return askAndBid[1];
+    }
+  } else {
+    if (order.side === types.OrderSide.BUY) {
+      if (orderPrice >= askAndBid[0]) {
+        return askAndBid[0];
+      } else {
+        return orderPrice;
+      }
+    } else {
+      if (orderPrice <= askAndBid[1]) {
+        return askAndBid[1];
+      } else {
+        return orderPrice;
+      }
+    }
+  }
+}
+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 = calcScaledOrderAvgOrderPrice(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 calcScaledOrderPrices(inputs) {
+  const { min_price, max_price, total_orders, quote_dp } = inputs;
+  if (!min_price || !max_price || !total_orders) {
+    return [];
+  }
+  const minPrice3 = new utils.Decimal(min_price);
+  const maxPrice3 = new utils.Decimal(max_price);
+  const totalOrders = Number(total_orders);
+  const priceStep = maxPrice3.minus(minPrice3).div(totalOrders - 1);
+  const prices = [];
+  for (let i = 0; i < totalOrders; i++) {
+    prices[i] = minPrice3.plus(priceStep.mul(i)).todp(quote_dp).toString();
+  }
+  return prices;
+}
+function getScaledOrderSkew(inputs) {
+  const { skew, distribution_type, total_orders } = inputs;
+  if (distribution_type === types.DistributionType.FLAT) {
+    return 1;
+  } else if (distribution_type === types.DistributionType.ASCENDING) {
+    return total_orders;
+  } else if (distribution_type === types.DistributionType.DESCENDING) {
+    return 1 / total_orders;
+  }
+  return skew;
+}
+function calcScaledOrderWeights(inputs) {
+  const { total_orders, distribution_type, skew } = inputs;
+  const weights = [];
+  if (!total_orders || !distribution_type || distribution_type === types.DistributionType.CUSTOM && (!skew || skew <= 0 || skew > 100)) {
+    return {
+      weights: [],
+      sumWeights: 0,
+      minWeight: 0
+    };
+  }
+  const totalOrders = Number(total_orders);
+  const skewNum = getScaledOrderSkew({
+    skew,
+    distribution_type,
+    total_orders: totalOrders
+  });
+  for (let i = 0; i < totalOrders; i++) {
+    weights[i] = 1 + (skewNum - 1) * i / (totalOrders - 1);
+  }
+  const sumWeights = weights.reduce((acc, cur) => acc + cur, 0);
+  const minWeight = weights.reduce(
+    (min3, current) => current < min3 ? current : min3,
+    weights?.[0]
+  );
+  return {
+    weights,
+    sumWeights,
+    minWeight
+  };
+}
+function calcScaledOrderQtys(inputs) {
+  const {
+    order_quantity = 0,
+    total_orders = 0,
+    distribution_type,
+    skew,
+    base_dp,
+    base_tick
+  } = inputs;
+  const qtys = [];
+  if (!order_quantity || !total_orders) {
+    return [];
+  }
+  const { weights, sumWeights } = calcScaledOrderWeights({
+    total_orders,
+    distribution_type,
+    skew
+  });
+  for (let i = 0; i < total_orders; i++) {
+    let qty = new utils.Decimal(order_quantity).mul(weights[i]).div(sumWeights);
+    if (base_tick > 1) {
+      qty = qty.div(base_tick).todp(0, utils.Decimal.ROUND_DOWN).mul(base_tick);
+    } else {
+      qty = qty.todp(base_dp);
+    }
+    qtys[i] = qty.toString();
+  }
+  return qtys;
+}
+function calcScaledOrderBatchBody(order, symbolInfo) {
+  if (!validateScaledOrderInput(order)) {
+    return [];
+  }
+  try {
+    const { base_dp, quote_dp, base_tick } = symbolInfo;
+    const {
+      symbol,
+      side,
+      order_quantity,
+      min_price,
+      max_price,
+      total_orders,
+      distribution_type,
+      skew,
+      reduce_only,
+      visible_quantity
+    } = order;
+    const prices = calcScaledOrderPrices({
+      min_price,
+      max_price,
+      total_orders,
+      quote_dp
+    });
+    const qtys = calcScaledOrderQtys({
+      side,
+      order_quantity,
+      total_orders,
+      distribution_type,
+      skew,
+      base_dp,
+      base_tick
+    });
+    const now = Date.now();
+    const orders = prices.map((price, index) => {
+      const subOrder = {
+        symbol,
+        side,
+        // this order type is scaled order, so we need to set the order type to limit
+        order_type: types.OrderType.LIMIT,
+        order_quantity: qtys[index],
+        order_price: price,
+        reduce_only,
+        // it will be used for identify the scaled order from ws
+        client_order_id: `scaled_${index}_${now}`
+      };
+      if (visible_quantity === 0) {
+        subOrder.visible_quantity = visible_quantity;
+      }
+      return subOrder;
+    });
+    return orders;
+  } catch (error) {
+    return [];
+  }
+}
+function calcScaledOrderAvgOrderPrice(order, symbolInfo, askAndBid) {
+  if (!validateScaledOrderInput(order)) {
+    return null;
+  }
+  try {
+    const orders = calcScaledOrderBatchBody(order, symbolInfo);
+    const sumQtys = orders.reduce((acc, order2) => {
+      return acc.plus(new utils.Decimal(order2.order_quantity));
+    }, utils.zero);
+    const totalNational = orders.reduce((acc, order2) => {
+      const orderPrice = getOrderPrice(order2, askAndBid);
+      return acc.plus(new utils.Decimal(orderPrice).mul(order2.order_quantity));
+    }, utils.zero);
+    return totalNational.div(sumQtys).todp(symbolInfo.quote_dp).toNumber();
+  } catch (error) {
+    return null;
+  }
+}
+function validateScaledOrderInput(order) {
+  const {
+    min_price,
+    max_price,
+    order_quantity,
+    total_orders,
+    distribution_type,
+    skew
+  } = order;
+  if (!min_price || !max_price || !order_quantity || !total_orders || !distribution_type || distribution_type === types.DistributionType.CUSTOM && (!skew || skew <= 0 || skew > 100) || total_orders < 2 || total_orders > 20) {
+    return false;
+  }
+  return true;
+}
+function calcScaledOrderMinTotalAmount(order, symbolInfo, askAndBid) {
+  try {
+    const minTotalAmount_baseMin = calcScaledOrderMinTotalAmountByBaseMin(
+      order,
+      symbolInfo
+    );
+    const minTotalAmount_minNotional = calcScaledOrderMinTotalAmountByMinNotional(order, symbolInfo, askAndBid);
+    const minTotalAmount = Math.max(
+      minTotalAmount_baseMin,
+      minTotalAmount_minNotional
+    );
+    return minTotalAmount;
+  } catch (error) {
+    return null;
+  }
+}
+function calcScaledOrderMinTotalAmountByBaseMin(order, symbolInfo) {
+  const { total_orders, distribution_type, skew } = order;
+  const { base_min, base_dp } = symbolInfo;
+  const { sumWeights, minWeight } = calcScaledOrderWeights({
+    total_orders,
+    distribution_type,
+    skew
+  });
+  const minTotalAmount = new utils.Decimal(base_min).mul(new utils.Decimal(sumWeights).div(minWeight)).todp(base_dp, utils.Decimal.ROUND_UP).toNumber();
+  return minTotalAmount;
+}
+function calcScaledOrderMinTotalAmountByMinNotional(order, symbolInfo, askAndBid) {
+  const { base_dp, min_notional } = symbolInfo;
+  const orders = calcScaledOrderBatchBody(order, symbolInfo);
+  const { total_orders, distribution_type, skew } = order;
+  const { weights, sumWeights } = calcScaledOrderWeights({
+    total_orders,
+    distribution_type,
+    skew
+  });
+  const minQtys = orders.map((order2, i) => {
+    const orderPrice = getOrderPrice(order2, 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,
+    minQtys?.[0]
+  );
+  return max_minQty.todp(base_dp, utils.Decimal.ROUND_UP).toNumber();
+}
+
+// src/services/orderCreator/scaledOrderCreator.ts
+var ScaledOrderCreator = class extends BaseOrderCreator {
+  constructor() {
+    super(...arguments);
+    this.orderType = types.OrderType.SCALED;
+  }
+  create(values2, config) {
+    const orders = calcScaledOrderBatchBody(values2, config.symbol);
+    const { total_orders, distribution_type, skew } = values2;
+    const order = {
+      ...this.baseOrder(values2),
+      total_orders,
+      distribution_type,
+      skew,
+      orders
+    };
+    return ramda.pick(
+      [
+        "symbol",
+        "order_quantity",
+        "visible_quantity",
+        "reduce_only",
+        "side",
+        "order_type",
+        "orders",
+        "total_orders",
+        "distribution_type",
+        "skew"
+      ],
+      order
+    );
+  }
+  validatePrice(values2, config) {
+    const errors = {};
+    const { side, min_price, max_price } = values2;
+    const { price_range, price_scope, quote_max, quote_min, quote_dp } = config.symbol;
+    const maxPriceNumber = perp.order.maxPrice(config.markPrice, price_range);
+    const minPriceNumber = perp.order.minPrice(config.markPrice, price_range);
+    const scopePriceNumber = perp.order.scopePrice(
+      config.markPrice,
+      price_scope,
+      side
+    );
+    const priceRange = side === types.OrderSide.BUY ? {
+      min: scopePriceNumber,
+      max: maxPriceNumber
+    } : {
+      min: minPriceNumber,
+      max: scopePriceNumber
+    };
+    const minPrice3 = Number(min_price || 0);
+    const maxPrice3 = Number(max_price || 0);
+    if (!min_price) {
+      errors.min_price = OrderValidation.required("min_price");
+    } else {
+      if (minPrice3 < priceRange?.min) {
+        errors.min_price = OrderValidation.min(
+          "min_price",
+          new utils.Decimal(priceRange.min).todp(quote_dp).toString()
+        );
+      } else if (minPrice3 < quote_min) {
+        errors.min_price = OrderValidation.min("min_price", quote_min);
+      } else if (minPrice3 > maxPrice3) {
+        errors.min_price = OrderValidation.max("min_price", max_price);
+      }
+    }
+    if (!max_price) {
+      errors.max_price = OrderValidation.required("max_price");
+    } else {
+      if (maxPrice3 < priceRange?.min) {
+        errors.max_price = OrderValidation.min(
+          "max_price",
+          new utils.Decimal(priceRange.min).todp(quote_dp).toString()
+        );
+      } else if (maxPrice3 > priceRange?.max) {
+        errors.max_price = OrderValidation.max(
+          "max_price",
+          new utils.Decimal(priceRange.max).todp(quote_dp).toString()
+        );
+      } else if (maxPrice3 > quote_max) {
+        errors.max_price = OrderValidation.max("max_price", quote_max);
+      }
+    }
+    return errors;
+  }
+  async validate(values2, config) {
+    const { base_dp } = config.symbol;
+    const { maxQty, askAndBid } = config;
+    const { order_quantity, total_orders, distribution_type, skew } = values2;
+    const errors = this.validatePrice(values2, config);
+    if (!total_orders) {
+      errors.total_orders = OrderValidation.required("total_orders");
+    } else {
+      const totalOrdersNum = Number(total_orders);
+      if (totalOrdersNum < 2 || totalOrdersNum > 20) {
+        errors.total_orders = OrderValidation.range("total_orders", 2, 20);
+      }
+    }
+    if (distribution_type === types.DistributionType.CUSTOM) {
+      if (!skew) {
+        errors.skew = OrderValidation.required("skew");
+      } else {
+        const skewNum = Number(skew);
+        if (skewNum <= 0) {
+          errors.skew = OrderValidation.min("skew", 0);
+        } else if (skewNum > 100) {
+          errors.skew = OrderValidation.max("skew", 100);
+        }
+      }
+    }
+    if (!order_quantity) {
+      errors.order_quantity = OrderValidation.required("order_quantity");
+    } else {
+      const qty = new utils.Decimal(order_quantity);
+      if (qty.gt(maxQty)) {
+        errors.order_quantity = OrderValidation.max(
+          "order_quantity",
+          new utils.Decimal(maxQty).todp(base_dp).toString()
+        );
+      } else if (!errors.skew && !errors.total_orders) {
+        const minTotalAmount = calcScaledOrderMinTotalAmount(
+          values2,
+          config.symbol,
+          askAndBid
+        );
+        if (minTotalAmount && qty.lt(minTotalAmount)) {
+          errors.order_quantity = OrderValidation.min(
+            "order_quantity",
+            minTotalAmount
+          );
+        }
+      }
+    }
+    return errors;
+  }
+};
+var { maxPrice: maxPrice2, minPrice: minPrice2, scopePrice: scopePrice2 } = perp.order;
+var StopLimitOrderCreator = class extends BaseOrderCreator {
+  constructor() {
+    super(...arguments);
+    this.orderType = types.OrderType.STOP_LIMIT;
+  }
+  create(values2, config) {
+    this.totalToQuantity(values2, config);
+    const order = {
+      ...this.baseOrder(values2),
+      trigger_price: values2.trigger_price,
+      algo_type: types.AlgoOrderRootType.STOP,
+      type: types.OrderType.LIMIT,
+      quantity: values2["order_quantity"],
+      price: values2["order_price"],
+      trigger_price_type: types.TriggerPriceType.MARK_PRICE
+    };
+    return ramda.pick(
+      [
+        "symbol",
+        "trigger_price",
+        "algo_type",
+        "type",
+        "quantity",
+        "price",
+        "trigger_price_type",
+        "side",
+        "reduce_only",
+        "visible_quantity"
+      ],
+      order
+    );
+  }
+  validate(values2, config) {
+    return this.baseValidate(values2, config).then((errors) => {
+      const { order_price, trigger_price, side } = values2;
+      const { symbol } = config;
+      const { price_range, price_scope, quote_max, quote_min } = symbol;
+      if (!trigger_price) {
+        errors.trigger_price = OrderValidation.required("trigger_price");
+      }
+      if (!order_price) {
+        errors.order_price = OrderValidation.required("order_price");
+      }
+      if (trigger_price > quote_max) {
+        errors.trigger_price = OrderValidation.max("trigger_price", quote_max);
+      } else if (trigger_price < quote_min) {
+        errors.trigger_price = OrderValidation.min("trigger_price", quote_min);
+      } else {
+        if (trigger_price && order_price) {
+          const price = new utils.Decimal(order_price);
+          const maxPriceNumber = maxPrice2(trigger_price, price_range);
+          const minPriceNumber = minPrice2(trigger_price, price_range);
+          const scropePriceNumbere = scopePrice2(
+            trigger_price,
+            price_scope,
+            side
+          );
+          const priceRange = side === "BUY" ? {
+            min: scropePriceNumbere,
+            max: maxPriceNumber
+          } : {
+            min: minPriceNumber,
+            max: scropePriceNumbere
+          };
+          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;
+    });
+  }
+};
+var StopMarketOrderCreator = class extends BaseOrderCreator {
+  create(values2) {
+    const order = {
+      ...this.baseOrder(values2),
+      // order_price: values.order_price,
+      trigger_price: values2.trigger_price,
+      algo_type: types.AlgoOrderRootType.STOP,
+      type: types.OrderType.MARKET,
+      quantity: values2["order_quantity"],
+      // price: values["order_price"],
+      trigger_price_type: types.TriggerPriceType.MARK_PRICE
+    };
+    return ramda.pick(
       [
         "symbol",
         "trigger_price",
@@ -5456,18 +6139,6 @@ var StopMarketOrderCreator = class extends BaseOrderCreator {
     });
   }
 };
-
-// src/services/orderCreator/postOnlyCreator.ts
-var PostOnlyOrderCreator = class extends LimitOrderCreator {
-};
-
-// src/services/orderCreator/fokCreator.ts
-var FOKOrderCreator = class extends LimitOrderCreator {
-};
-
-// src/services/orderCreator/iocCreator.ts
-var IOCOrderCreator = class extends LimitOrderCreator {
-};
 var BaseAlgoOrderCreator = class {
   /**
    * base validate
@@ -5671,216 +6342,58 @@ var TPSLPositionOrderCreator = class extends BaseAlgoOrderCreator {
         type: types.OrderType.CLOSE_POSITION,
         trigger_price: tp_trigger_price,
         trigger_price_type: types.TriggerPriceType.MARK_PRICE,
-        symbol: values2.symbol,
-        is_activated: !!values2.tp_trigger_price
-      });
-    }
-    if (typeof values2.sl_trigger_price !== "undefined") {
-      const sl_trigger_price = !!values2.sl_trigger_price ? new utils.Decimal(values2.sl_trigger_price).todp(config.symbol.quote_dp).toNumber() : values2.sl_trigger_price;
-      child_orders.push({
-        algo_type: types.AlgoOrderType.STOP_LOSS,
-        reduce_only: true,
-        side,
-        type: types.OrderType.CLOSE_POSITION,
-        trigger_price: sl_trigger_price,
-        trigger_price_type: types.TriggerPriceType.MARK_PRICE,
-        symbol: values2.symbol,
-        is_activated: !!values2.sl_trigger_price
-      });
-    }
-    return {
-      algo_type: types.AlgoOrderRootType.POSITIONAL_TP_SL,
-      trigger_price_type: types.TriggerPriceType.MARK_PRICE,
-      // reduce_only: true,
-      symbol: values2.symbol,
-      child_orders
-    };
-  }
-  crateUpdateOrder(values2, oldValue, config) {
-    const data = this.create(values2, config);
-    const newData = [];
-    data.child_orders.forEach((order) => {
-      const oldOrder = oldValue.child_orders?.find(
-        (oldOrder2) => oldOrder2.algo_type === order.algo_type
-      );
-      if (oldOrder) {
-        if (!order.is_activated) {
-          newData.push({
-            is_activated: false,
-            order_id: Number(oldOrder.algo_order_id)
-          });
-        } else if (oldOrder.trigger_price !== order.trigger_price) {
-          newData.push({
-            trigger_price: order.trigger_price,
-            order_id: Number(oldOrder.algo_order_id)
-          });
-        }
-      }
-    });
-    return [
-      {
-        child_orders: newData
-      },
-      data
-    ];
-  }
-};
-async function bracketOrderValidator(values2, config) {
-  const result = /* @__PURE__ */ Object.create(null);
-  await Promise.resolve();
-  const { tp_trigger_price, sl_trigger_price, side } = values2;
-  const qty = Number(values2.quantity);
-  const maxQty = config.maxQty;
-  const type = values2.order_type;
-  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 = OrderValidation.max("quantity", config.maxQty);
-  }
-  if (Number(tp_trigger_price) < 0) {
-    result.tp_trigger_price = OrderValidation.min("tp_trigger_price", 0);
-  }
-  if (Number(sl_trigger_price) < 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 = OrderValidation.min(
-        "sl_trigger_price",
-        slTriggerPriceScope
-      );
-    }
-    if (!!tp_trigger_price && Number(tp_trigger_price) <= 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 = OrderValidation.max(
-        "tp_trigger_price",
-        quote_max
-      );
-    }
-    if (!!sl_trigger_price && Number(sl_trigger_price) < 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 = OrderValidation.max(
-        "sl_trigger_price",
-        slTriggerPriceScope
-      );
-    }
-    if (!!tp_trigger_price && Number(tp_trigger_price) >= 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 = OrderValidation.max(
-        "tp_trigger_price",
-        quote_max
-      );
-    }
-    if (!!sl_trigger_price && Number(sl_trigger_price) < quote_min) {
-      result.sl_trigger_price = OrderValidation.min(
-        "sl_trigger_price",
-        quote_min
-      );
-    }
-  }
-  return Object.keys(result).length > 0 ? result : null;
-}
-
-// src/services/orderCreator/bracketLimitOrderCreator.ts
-var BracketLimitOrderCreator = class extends LimitOrderCreator {
-  // orderType: OrderType;
-  create(values2, config) {
-    const order = super.create(values2, config);
-    return {
-      ...order,
-      quantity: order.order_quantity,
-      type: order.order_type,
-      price: order.order_price
-    };
-  }
-  async validate(values2, config) {
-    const value = await super.validate(values2, config);
-    const bracketData = await bracketOrderValidator(values2, config);
-    return { ...value, ...bracketData };
-  }
-};
-var BracketMarketOrderCreator = class extends MarketOrderCreator {
-  constructor() {
-    super(...arguments);
-    this.orderType = types.OrderType.MARKET;
-  }
-  create(values2) {
-    const order = super.create(values2);
+        symbol: values2.symbol,
+        is_activated: !!values2.tp_trigger_price
+      });
+    }
+    if (typeof values2.sl_trigger_price !== "undefined") {
+      const sl_trigger_price = !!values2.sl_trigger_price ? new utils.Decimal(values2.sl_trigger_price).todp(config.symbol.quote_dp).toNumber() : values2.sl_trigger_price;
+      child_orders.push({
+        algo_type: types.AlgoOrderType.STOP_LOSS,
+        reduce_only: true,
+        side,
+        type: types.OrderType.CLOSE_POSITION,
+        trigger_price: sl_trigger_price,
+        trigger_price_type: types.TriggerPriceType.MARK_PRICE,
+        symbol: values2.symbol,
+        is_activated: !!values2.sl_trigger_price
+      });
+    }
     return {
-      ...order,
-      quantity: order.order_quantity,
-      type: order.order_type,
-      price: order.order_price
-    };
-  }
-  async validate(values2, config) {
-    const value = await super.validate(values2, config);
-    const bracketData = await bracketOrderValidator(values2, config);
-    return { ...value, ...bracketData };
-  }
-};
-var BBOOrderCreator = class extends BaseOrderCreator {
-  create(values2) {
-    const order = {
-      ...this.baseOrder(values2),
-      level: values2.level
+      algo_type: types.AlgoOrderRootType.POSITIONAL_TP_SL,
+      trigger_price_type: types.TriggerPriceType.MARK_PRICE,
+      // reduce_only: true,
+      symbol: values2.symbol,
+      child_orders
     };
-    return ramda.pick(
-      [
-        "symbol",
-        "order_quantity",
-        "visible_quantity",
-        "reduce_only",
-        "side",
-        "order_type",
-        "level"
-      ],
-      order
-    );
   }
-  async validate(values2, configs) {
-    return this.baseValidate(values2, configs).then((errors) => {
-      delete errors["total"];
-      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 minNotional = getMinNotional({
-        base_tick,
-        quote_tick,
-        price: order_price,
-        qty: order_quantity,
-        min_notional,
-        quote_dp,
-        base_dp
-      });
-      if (minNotional !== void 0 && !reduce_only) {
-        errors.total = {
-          type: "min",
-          message: `The order value should be greater or equal to ${minNotional} USDC`,
-          value: minNotional
-        };
+  crateUpdateOrder(values2, oldValue, config) {
+    const data = this.create(values2, config);
+    const newData = [];
+    data.child_orders.forEach((order) => {
+      const oldOrder = oldValue.child_orders?.find(
+        (oldOrder2) => oldOrder2.algo_type === order.algo_type
+      );
+      if (oldOrder) {
+        if (!order.is_activated) {
+          newData.push({
+            is_activated: false,
+            order_id: Number(oldOrder.algo_order_id)
+          });
+        } else if (oldOrder.trigger_price !== order.trigger_price) {
+          newData.push({
+            trigger_price: order.trigger_price,
+            order_id: Number(oldOrder.algo_order_id)
+          });
+        }
       }
-      return errors;
     });
+    return [
+      {
+        child_orders: newData
+      },
+      data
+    ];
   }
 };
 
@@ -5909,6 +6422,8 @@ var OrderFactory = class {
         return new StopLimitOrderCreator();
       case types.OrderType.STOP_MARKET:
         return new StopMarketOrderCreator();
+      case types.OrderType.SCALED:
+        return new ScaledOrderCreator();
       case types.AlgoOrderRootType.TP_SL:
         return new TPSLOrderCreator();
       case types.AlgoOrderRootType.POSITIONAL_TP_SL:
@@ -7172,6 +7687,9 @@ var usePrivateDataObserver = (options) => {
     return () => unsubscribe?.();
   }, [account7.accountId]);
   const isHoldingInit = React.useRef(false);
+  React.useEffect(() => {
+    isHoldingInit.current = false;
+  }, [state.accountId]);
   React.useEffect(() => {
     if (!holding) {
       return;
@@ -14531,137 +15049,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);
-  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) => {
-  return !!order.tp_trigger_price || !!order.sl_trigger_price;
-};
-var hasTPSL = (order) => {
-  return tpslFields.some((field) => !!order[field]);
-};
-var getPriceAndQty = (symbolOrOrder, askAndBid) => {
-  let quantity = Number(symbolOrOrder.order_quantity);
-  const orderPrice = Number(symbolOrOrder.order_price);
-  if (isNaN(quantity) || quantity <= 0) {
-    return null;
-  }
-  if (askAndBid.length === 0) {
-    return null;
-  }
-  if ((symbolOrOrder.order_type === types.OrderType.LIMIT || symbolOrOrder.order_type === types.OrderType.STOP_LIMIT) && isNaN(orderPrice))
-    return null;
-  let price;
-  if (symbolOrOrder.order_type === types.OrderType.MARKET || symbolOrOrder.order_type === types.OrderType.STOP_MARKET) {
-    if (symbolOrOrder.side === types.OrderSide.BUY) {
-      price = askAndBid[0];
-    } else {
-      price = askAndBid[1];
-    }
-  } else {
-    if (symbolOrOrder.side === types.OrderSide.BUY) {
-      if (orderPrice >= askAndBid[0]) {
-        price = askAndBid[0];
-      } else {
-        price = orderPrice;
-      }
-    } else {
-      if (orderPrice <= askAndBid[1]) {
-        price = askAndBid[1];
-      } else {
-        price = orderPrice;
-      }
-    }
-  }
-  if (symbolOrOrder.side === types.OrderSide.SELL) {
-    quantity = -quantity;
-  }
-  return { price, quantity };
-};
-var calcEstLiqPrice = (order, askAndBid, inputs) => {
-  const result = getPriceAndQty(order, askAndBid);
-  if (!result)
-    return null;
-  const { price, quantity } = result;
-  if (!price || !quantity)
-    return null;
-  const {
-    symbol,
-    baseIMR,
-    baseMMR,
-    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,
-    baseMMR,
-    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 result = getPriceAndQty(order, askAndBid);
-  const { totalCollateral, positions: positions3, symbol } = inputs;
-  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: "",
@@ -14674,7 +15061,12 @@ var initialOrderState = {
   sl_offset_percentage: "",
   tp_offset: "",
   sl_offset: "",
-  total: ""
+  total: "",
+  min_price: "",
+  max_price: "",
+  totalOrders: "",
+  distribution_type: "",
+  skew: ""
   // symbol: "",
 };
 var useOrderStore = (initialOrder) => {
@@ -14911,12 +15303,9 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
     [calculate2, options.symbolInfo, orderEntity, orderEntryActions]
   );
   const validate = (order, creator, options2) => {
-    const { markPrice, maxQty, estSlippage } = options2;
     return creator?.validate(order, {
-      symbol: symbolInfo,
-      maxQty,
-      markPrice,
-      estSlippage
+      ...options2,
+      symbol: symbolInfo
     });
   };
   const generateOrder = (creator, options2) => {
@@ -15098,7 +15487,8 @@ var useOrderEntry2 = (symbol, options = {}) => {
     return {
       markPrice: actions.getMarkPriceBySymbol(symbol),
       maxQty,
-      estSlippage
+      estSlippage,
+      askAndBid: askAndBid.current?.[0] || []
     };
   }, [maxQty, symbol, estSlippage]);
   const interactiveValidate = (order) => {
@@ -15198,25 +15588,36 @@ var useOrderEntry2 = (symbol, options = {}) => {
   const { freeCollateral, totalCollateral } = useCollateral();
   const estLiqPrice = React.useMemo(() => {
     const markPrice2 = actions.getMarkPriceBySymbol(symbol);
-    if (!markPrice2 || !accountInfo)
+    if (!markPrice2 || !accountInfo || !symbolInfo) {
       return null;
+    }
     const orderQuantity = Number(formattedOrder.order_quantity);
     if (orderQuantity === 0 || orderQuantity > maxQty) {
       return null;
     }
     const estLiqPrice2 = calcEstLiqPrice(formattedOrder, askAndBid.current[0], {
-      baseIMR: symbolInfo?.base_imr,
-      baseMMR: symbolInfo?.base_mmr,
       markPrice: markPrice2,
       totalCollateral,
       futures_taker_fee_rate: accountInfo.futures_taker_fee_rate,
       imr_factor: accountInfo.imr_factor[symbol],
       symbol,
-      positions: positions3
+      positions: positions3,
+      symbolInfo
     });
     return estLiqPrice2;
-  }, [formattedOrder, accountInfo, positions3, totalCollateral, symbol, maxQty]);
+  }, [
+    formattedOrder,
+    accountInfo,
+    positions3,
+    totalCollateral,
+    symbol,
+    maxQty,
+    symbolInfo
+  ]);
   const estLeverage = React.useMemo(() => {
+    if (!symbolInfo) {
+      return null;
+    }
     const orderQuantity = Number(formattedOrder.order_quantity);
     if (orderQuantity === 0 || orderQuantity > maxQty) {
       return null;
@@ -15224,9 +15625,18 @@ var useOrderEntry2 = (symbol, options = {}) => {
     return calcEstLeverage(formattedOrder, askAndBid.current[0], {
       totalCollateral,
       positions: positions3,
-      symbol
+      symbol,
+      symbolInfo
     });
-  }, [formattedOrder, accountInfo, positions3, totalCollateral, symbol, maxQty]);
+  }, [
+    formattedOrder,
+    accountInfo,
+    positions3,
+    totalCollateral,
+    symbol,
+    maxQty,
+    symbolInfo
+  ]);
   const resetErrors = () => {
     setMeta(
       immer$1.produce((draft) => {
@@ -15263,14 +15673,31 @@ var useOrderEntry2 = (symbol, options = {}) => {
       throw new types.SDKError("Order validation failed");
     }
     const order = generateOrder(creator, prepareData());
-    const result = await doCreateOrder(order);
+    const isScaledOrder = order.order_type === types.OrderType.SCALED;
+    const params = isScaledOrder ? { orders: order.orders } : order;
+    const result = await doCreateOrder(params);
     if (result.success) {
-      track2(types.TrackerEventName.placeOrderSuccess, {
+      let trackParams = {
         side: order.side,
         order_type: order.order_type,
         tp_sl: hasTPSL(formattedOrder),
         symbol: order.symbol
-      });
+      };
+      if (isScaledOrder) {
+        const skew = getScaledOrderSkew({
+          skew: order.skew,
+          distribution_type: order.distribution_type,
+          total_orders: order.total_orders
+        });
+        trackParams = {
+          ...trackParams,
+          order_type: "scaled",
+          distribution_type: order.distribution_type,
+          skew: new utils.Decimal(skew).todp(2).toNumber(),
+          total_orders: order.total_orders
+        };
+      }
+      track2(types.TrackerEventName.placeOrderSuccess, trackParams);
     }
     if (result.success && resetOnSuccess) {
       reset();
@@ -15455,6 +15882,7 @@ var useOrderEntity = (order, options) => {
     symbolInfo
   };
 };
+var canUnblockRegions = ["United States"];
 var useRestrictedInfo = (options) => {
   const {
     enableDefault = false,
@@ -15462,63 +15890,70 @@ var useRestrictedInfo = (options) => {
     customRestrictedRegions = [],
     content
   } = options || {};
-  const apiBaseUrl = useConfig("apiBaseUrl");
-  const [invalidWebCity, setInvalidWebCity] = React.useState([]);
-  const [invalidWebCountry, setInvalidWebCountry] = React.useState([]);
-  const [invalidRegions, setInvalidRegions] = React.useState([]);
-  const [allInvalidAreas, setAllInvalidAreas] = React.useState([]);
-  const [city, setCity] = React.useState("");
-  const [region, setRegion] = React.useState("");
   const [ip, setIp] = React.useState("");
+  const [allInvalidAreas, setAllInvalidAreas] = React.useState([]);
   const [restrictedOpen, setRestrictedOpen] = React.useState(false);
+  const [canUnblock, setCanUnblock] = React.useState(false);
+  const [accessRestricted, setAccessRestricted] = useLocalStorage("orderly_access_restricted", void 0);
+  const { data: ipInfo } = useQuery("/v1/ip_info");
+  const { data: restrictedAreas } = useQuery(
+    "/v1/restricted_areas"
+  );
   React.useEffect(() => {
-    const fetchData = async () => {
-      try {
-        const areaRes = await fetch(`${apiBaseUrl}/v1/restricted_areas`);
-        const areaResdata = await areaRes.json();
-        const ipRes = await fetch(`${apiBaseUrl}/v1/ip_info`);
-        const ipData = await ipRes.json();
-        if (areaResdata.success && ipData.success) {
-          const invalidCountries = areaResdata?.data?.invalid_web_country?.toLocaleLowerCase()?.replace(/\s+/g, "").split(",");
-          const invalidCities = areaResdata?.data?.invalid_web_city?.toLocaleLowerCase()?.replace(/\s+/g, "").split(",");
-          const combinedInvalidRegions = (enableDefault ? invalidCities.concat(invalidCountries) : []).concat(
-            customRestrictedRegions?.map(
-              (item) => item?.replace(/\s+/g, "")?.toLocaleLowerCase()
-            )
-          );
-          const allInvalidAreas2 = [
-            enableDefault ? areaResdata?.data?.invalid_web_country : "",
-            enableDefault ? areaResdata?.data?.invalid_web_city : "",
-            customRestrictedRegions?.join(", ")
-          ].filter((item) => !!item);
-          setInvalidWebCity(invalidCities);
-          setInvalidWebCountry(invalidCountries);
-          setInvalidRegions(combinedInvalidRegions);
-          setAllInvalidAreas(allInvalidAreas2);
-          const { city: city2, region: region2, ip: ip2 } = ipData.data;
-          setCity(city2);
-          setRegion(region2);
-          setIp(ip2);
-          if (combinedInvalidRegions.includes(
-            ipData?.data?.city?.replace(/\s+/g, "").toLocaleLowerCase()
-          ) || combinedInvalidRegions.includes(
-            ipData?.data?.region?.replace(/\s+/g, "").toLocaleLowerCase()
-          ) || customRestrictedIps.includes(ipData?.data?.ip)) {
-            setRestrictedOpen(true);
-          }
+    if (!restrictedAreas || !ipInfo) {
+      return;
+    }
+    try {
+      const { invalid_web_country, invalid_web_city } = restrictedAreas;
+      const invalidCountries = invalid_web_country?.toLowerCase().replace(/\s+/g, "").split(",");
+      const invalidCities = invalid_web_city?.toLowerCase().replace(/\s+/g, "").split(",");
+      const formattedCustomRegions = customRestrictedRegions?.map(
+        (item) => formatRegion(item)
+      );
+      const combinedInvalidRegions = [
+        ...formattedCustomRegions,
+        ...enableDefault ? [...invalidCountries, ...invalidCities] : []
+      ];
+      const allInvalidAreas2 = [
+        enableDefault ? invalid_web_country : "",
+        enableDefault ? invalid_web_city : "",
+        customRestrictedRegions?.join(", ")
+      ].filter((item) => !!item);
+      const { city, region, ip: ip2 } = ipInfo;
+      const formattedCity = formatRegion(city);
+      const formattedRegion = formatRegion(region);
+      const showRestricted = accessRestricted && (combinedInvalidRegions.includes(formattedCity) || combinedInvalidRegions.includes(formattedRegion) || customRestrictedIps.includes(ip2));
+      for (const item of canUnblockRegions) {
+        if (formatRegion(item) === formatRegion(region)) {
+          setCanUnblock(true);
         }
-      } catch (error) {
       }
-    };
-    fetchData();
-  }, [apiBaseUrl]);
+      setIp(ip2);
+      setAllInvalidAreas(allInvalidAreas2);
+      setRestrictedOpen(showRestricted);
+    } catch (error) {
+    }
+  }, [
+    ipInfo,
+    restrictedAreas,
+    enableDefault,
+    customRestrictedIps,
+    customRestrictedRegions,
+    accessRestricted
+  ]);
   return {
     ip,
     invalidRegions: allInvalidAreas,
     restrictedOpen,
-    content
+    content,
+    canUnblock,
+    accessRestricted,
+    setAccessRestricted
   };
 };
+function formatRegion(region) {
+  return region?.replace(/\s+/g, "").toLowerCase();
+}
 var usePositionClose = (options) => {
   const { position, order: initialOrder } = options;
   const { type, quantity, price } = initialOrder;
@@ -15526,6 +15961,10 @@ var usePositionClose = (options) => {
   const [errors, setErrors] = React.useState(null);
   const symbolsInfo = useSymbolsInfo();
   const { data: markPrices } = useMarkPricesStream();
+  const markPricesRef = React.useRef(markPrices);
+  React.useEffect(() => {
+    markPricesRef.current = markPrices;
+  }, [markPrices]);
   const [doCreateOrder, { isMutating }] = useSubAccountMutation(
     "/v1/order",
     "POST",
@@ -15574,11 +16013,12 @@ var usePositionClose = (options) => {
       const errors2 = await creator.validate(data, {
         symbol: symbolsInfo[symbol](),
         maxQty,
-        markPrice: markPrices[symbol]
+        // use ref to avoid re-render when markPrices change
+        markPrice: markPricesRef.current[symbol]
       });
       return errors2;
     },
-    [markPrices, maxQty, symbol, symbolsInfo]
+    [maxQty, symbol, symbolsInfo]
   );
   React.useEffect(() => {
     validate(closeOrderData).then((errors2) => {