@orderly.network/hooks 2.2.0 → 2.3.0

package/dist/index.js

@@ -1,9 +1,9 @@
 'use strict';
 
-var useSWR = require('swr');
 var net = require('@orderly.network/net');
-var React = require('react');
+var useSWR = require('swr');
 var types = require('@orderly.network/types');
+var React = require('react');
 var useSWRMutation = require('swr/mutation');
 var useConstant = require('use-constant');
 var core = require('@orderly.network/core');
@@ -12,9 +12,9 @@ var lodash = require('lodash');
 var useSWRInfinite = require('swr/infinite');
 var amplitude = require('@amplitude/analytics-browser');
 var jsxRuntime = require('react/jsx-runtime');
-var ramda = require('ramda');
 var zustand = require('zustand');
 var immer = require('zustand/middleware/immer');
+var ramda = require('ramda');
 var perp = require('@orderly.network/perp');
 var useSWRSubscription = require('swr/subscription');
 var useDebounce = require('use-debounce');
@@ -44,7 +44,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var useSWR__default = /*#__PURE__*/_interopDefault(useSWR);
+var useSWR__namespace = /*#__PURE__*/_interopNamespace(useSWR);
 var React__default = /*#__PURE__*/_interopDefault(React);
 var useSWRMutation__default = /*#__PURE__*/_interopDefault(useSWRMutation);
 var useConstant__default = /*#__PURE__*/_interopDefault(useConstant);
@@ -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.2.0";
+  window.__ORDERLY_VERSION__["@orderly.network/hooks"] = "2.3.0";
 }
-var version_default = "2.2.0";
+var version_default = "2.3.0";
 var fetcher = (url, init2 = {}, queryOptions) => net.get(url, init2, queryOptions?.formatter);
 var OrderlyContext = React.createContext({
   // configStore: new MemoryConfigStore(),
@@ -84,13 +84,15 @@ function useConfig(key, defaultValue) {
   }
   return configStore;
 }
+
+// src/useQuery.ts
 var useQuery = (query, options) => {
   const apiBaseUrl = useConfig("apiBaseUrl");
   const { formatter, ...swrOptions } = options || {};
   if (typeof apiBaseUrl === "undefined") {
     throw new types.SDKError("please add OrderlyConfigProvider to your app");
   }
-  return useSWR__default.default(
+  return useSWR__namespace.default(
     query,
     (url, init2) => fetcher(url.startsWith("http") ? url : `${apiBaseUrl}${url}`, init2, {
       formatter
@@ -109,14 +111,10 @@ var useLazyQuery = (query, options) => {
     (url, options2) => {
       url = url.startsWith("http") ? url : `${apiBaseUrl}${url}`;
       if (options2?.arg) {
-        const queryString = Object.entries(options2.arg).map(
-          ([key, value]) => `${key}=${encodeURIComponent(value)}`
-        ).join("&");
+        const queryString = Object.entries(options2.arg).map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&");
         url = `${url}?${queryString}`;
       }
-      return fetcher(url, init2, {
-        formatter
-      });
+      return fetcher(url, init2, { formatter });
     },
     swrOptions
   );
@@ -132,20 +130,20 @@ var useAccountInstance = () => {
       "keyStore is not defined, please use OrderlyProvider and provide keyStore"
     );
   }
-  const account5 = useConstant__default.default(() => {
-    let account6 = core.SimpleDI.get("account");
-    if (!account6) {
-      account6 = new core.Account(
+  const account7 = useConstant__default.default(() => {
+    let account8 = core.SimpleDI.get("account");
+    if (!account8) {
+      account8 = new core.Account(
         configStore,
         keyStore,
         // getWalletAdapter,
         walletAdapters
       );
-      core.SimpleDI.registerByName("account", account6);
+      core.SimpleDI.registerByName("account", account8);
     }
-    return account6;
+    return account8;
   });
-  return account5;
+  return account7;
 };
 var fetcher2 = (url, options) => {
   const init2 = {
@@ -169,7 +167,7 @@ var useMutation = (url, method = "POST", options) => {
   if (!url.startsWith("http")) {
     fullUrl = `${apiBaseUrl}${url}`;
   }
-  const account5 = useAccountInstance();
+  const account7 = useAccountInstance();
   const { trigger, data, error, reset, isMutating } = useSWRMutation__default.default(
     fullUrl,
     // method === "POST" ? fetcher : deleteFetcher,
@@ -187,7 +185,7 @@ var useMutation = (url, method = "POST", options) => {
       url: newUrl,
       data: data2
     };
-    const signer = account5.signer;
+    const signer = account7.signer;
     const signature = await signer.sign(payload, utils.getTimestamp());
     return trigger(
       {
@@ -196,7 +194,7 @@ var useMutation = (url, method = "POST", options) => {
         method,
         signature: {
           ...signature,
-          "orderly-account-id": account5.accountId
+          "orderly-account-id": account7.accountId
         }
       },
       options2
@@ -214,22 +212,22 @@ var useMutation = (url, method = "POST", options) => {
 };
 var signatureMiddleware = (useSWRNext) => {
   const apiBaseUrl = useConfig("apiBaseUrl");
-  return (key, fetcher3, config) => {
+  return (key, fetcher4, config) => {
     try {
       const extendedFetcher = async (args) => {
-        let url = Array.isArray(args) ? args[0] : args;
-        let account5 = core.SimpleDI.get("account");
-        let fullUrl = `${apiBaseUrl}${url}`;
-        const signer = account5.signer;
+        const url = Array.isArray(args) ? args[0] : args;
+        const account7 = core.SimpleDI.get("account");
+        const fullUrl = `${apiBaseUrl}${url}`;
+        const signer = account7.signer;
         const payload = {
           method: "GET",
           url
         };
         const signature = await signer.sign(payload, utils.getTimestamp());
-        return fetcher3(fullUrl, {
+        return fetcher4(fullUrl, {
           headers: {
             ...signature,
-            "orderly-account-id": account5.accountId
+            "orderly-account-id": account7.accountId
           }
         });
       };
@@ -296,16 +294,47 @@ var useTrack = () => {
     setIdentify
   };
 };
+var WS_NAME = "nativeWebsocketClient";
+var useWS = () => {
+  const { configStore } = React.useContext(OrderlyContext);
+  const ws = useConstant__default.default(() => {
+    let websocketClient = core.SimpleDI.get(WS_NAME);
+    const account7 = core.SimpleDI.get(core.Account.instanceName);
+    if (!websocketClient) {
+      websocketClient = new net.WS({
+        networkId: configStore.get("networkId"),
+        publicUrl: configStore.get("publicWsUrl"),
+        privateUrl: configStore.get("privateWsUrl"),
+        onSigntureRequest: async (accountId) => {
+          const signer = account7.signer;
+          const timestamp = utils.getTimestamp();
+          const result = await signer.signText(timestamp.toString());
+          return { ...result, timestamp };
+        }
+      });
+      if ((account7.stateValue.status === types.AccountStatusEnum.EnableTrading || account7.stateValue.status === types.AccountStatusEnum.EnableTradingWithoutConnected) && account7.accountId) {
+        websocketClient.openPrivate(account7.accountId);
+      }
+      account7.on("change:status", (nextState) => {
+        if ((nextState.status === types.AccountStatusEnum.EnableTrading || nextState.status === types.AccountStatusEnum.EnableTradingWithoutConnected) && account7.accountId) {
+          websocketClient.openPrivate(account7.accountId);
+        } else {
+          websocketClient.closePrivate(1e3, "switch account");
+        }
+      });
+      if (typeof window !== "undefined") {
+        utils.getGlobalObject()["__Orderly_WS"] = websocketClient;
+      }
+      core.SimpleDI.registerByName(WS_NAME, websocketClient);
+    }
+    return websocketClient;
+  });
+  return ws;
+};
 
 // src/useAccount.ts
 var useAccount = () => {
-  const {
-    configStore,
-    keyStore
-    // onWalletConnect,
-    // onWalletDisconnect,
-    // onSetChain,
-  } = React.useContext(OrderlyContext);
+  const { configStore, keyStore } = React.useContext(OrderlyContext);
   if (!configStore)
     throw new types.SDKError(
       "configStore is not defined, please use OrderlyProvider"
@@ -315,49 +344,83 @@ var useAccount = () => {
       "keyStore is not defined, please use OrderlyProvider and provide keyStore"
     );
   }
-  const account5 = useAccountInstance();
-  const [state, setState] = React.useState(account5.stateValue);
+  const account7 = useAccountInstance();
+  const [state, setState] = React.useState(account7.stateValue);
   const { track: track2 } = useTrack();
   const statusChangeHandler = (nextState) => {
     setState(() => nextState);
   };
   React.useEffect(() => {
-    account5.on("change:status", statusChangeHandler);
+    account7.on("change:status", statusChangeHandler);
     return () => {
-      account5.off("change:status", statusChangeHandler);
+      account7.off("change:status", statusChangeHandler);
     };
-  }, []);
+  }, [account7]);
   const createOrderlyKey = React.useCallback(
     async (remember) => {
       track2(types.TrackerEventName.signinSuccess, {
-        network: account5.chainId,
+        network: account7.chainId,
         wallet: state.connectWallet?.name
       });
-      return account5.createOrderlyKey(remember ? 365 : 30);
+      return account7.createOrderlyKey(remember ? 365 : 30).then((res) => {
+        return account7.restoreSubAccount().then((_) => {
+          return res;
+        });
+      });
+    },
+    [account7, state]
+  );
+  const ws = useWS();
+  const switchAccount = React.useCallback(
+    async (accountId) => {
+      ws.closePrivate(1e3, "switch account");
+      return account7.switchAccount(accountId);
     },
-    [account5, state]
+    [account7]
   );
   const createAccount = React.useCallback(async () => {
-    return account5.createAccount();
-  }, [account5]);
+    return account7.createAccount();
+  }, [account7]);
+  const createSubAccount = React.useCallback(
+    async (description) => {
+      return account7.createSubAccount(description);
+    },
+    [account7]
+  );
+  const updateSubAccount = React.useCallback(
+    async (value) => {
+      return account7.updateSubAccount(value);
+    },
+    [account7]
+  );
+  const refreshSubAccountBalances = React.useCallback(() => {
+    return account7.refreshSubAccountBalances();
+  }, [account7]);
+  const isSubAccount = React.useMemo(() => {
+    return state.accountId !== state.mainAccountId;
+  }, [state]);
   return {
-    account: account5,
+    account: account7,
     state,
-    // info: {},
-    // login,
+    isSubAccount,
+    isMainAccount: !isSubAccount,
+    subAccount: {
+      refresh: refreshSubAccountBalances,
+      create: createSubAccount,
+      update: updateSubAccount
+    },
+    switchAccount,
     createOrderlyKey,
     createAccount
-    // disconnect,
-    // connect,
-    // setChain,
-    // settlement,
   };
 };
+
+// src/usePrivateQuery.ts
 var usePrivateQuery = (query, options) => {
   const { formatter, ...swrOptions } = options || {};
   const { state } = useAccount();
   const middleware = Array.isArray(options?.use) ? options?.use ?? [] : [];
-  return useSWR__default.default(
+  return useSWR__namespace.default(
     () => state.status >= types.AccountStatusEnum.EnableTrading || state.status === types.AccountStatusEnum.EnableTradingWithoutConnected ? [query, state.accountId] : null,
     (url, init2) => {
       return fetcher(url, init2, { formatter });
@@ -365,7 +428,7 @@ var usePrivateQuery = (query, options) => {
     {
       ...swrOptions,
       use: [signatureMiddleware, ...middleware],
-      onError: (err) => {
+      onError: () => {
       }
     }
   );
@@ -376,6 +439,8 @@ var usePrivateInfiniteQuery = (getKey, options) => {
   const middleware = Array.isArray(restOptions?.use) ? restOptions?.use ?? [] : [];
   const result = useSWRInfinite__default.default(
     (pageIndex, previousPageData) => {
+      if (!getKey)
+        return null;
       const queryKey = getKey(pageIndex, previousPageData);
       if (queryKey && (state.status >= types.AccountStatusEnum.EnableTrading || state.status === types.AccountStatusEnum.EnableTradingWithoutConnected)) {
         return [queryKey, state.accountId];
@@ -423,7 +488,7 @@ var usePreLoadData = () => {
     }
   );
   const apiBaseUrl = useConfig("apiBaseUrl");
-  const { data: systemInfo } = useSWR__default.default(
+  const { data: systemInfo } = useSWR__namespace.default(
     "/v1/public/system_info",
     async (url, init2) => {
       const data = await fetch(
@@ -514,14 +579,16 @@ function useSessionStorage(key, initialValue) {
   );
   return [storedValue, setValue];
 }
-function useLocalStorage(key, initialValue) {
+function useLocalStorage(key, initialValue, options = {
+  parseJSON
+}) {
   const readValue = React.useCallback(() => {
     if (typeof window === "undefined") {
       return initialValue;
     }
     try {
       const item = window.localStorage.getItem(key);
-      return item ? parseJSON(item) : initialValue;
+      return item ? options.parseJSON(item) : initialValue;
     } catch (error) {
       return initialValue;
     }
@@ -650,43 +717,6 @@ var useTrackingInstance = () => {
   });
   return trackInstace;
 };
-var WS_NAME = "nativeWebsocketClient";
-var useWS = () => {
-  const { configStore } = React.useContext(OrderlyContext);
-  const ws = useConstant__default.default(() => {
-    let websocketClient = core.SimpleDI.get(WS_NAME);
-    const account5 = core.SimpleDI.get(core.Account.instanceName);
-    if (!websocketClient) {
-      websocketClient = new net.WS({
-        networkId: configStore.get("networkId"),
-        publicUrl: configStore.get("publicWsUrl"),
-        privateUrl: configStore.get("privateWsUrl"),
-        onSigntureRequest: async (accountId) => {
-          const signer = account5.signer;
-          const timestamp = utils.getTimestamp();
-          const result = await signer.signText(timestamp.toString());
-          return { ...result, timestamp };
-        }
-      });
-      if ((account5.stateValue.status === types.AccountStatusEnum.EnableTrading || account5.stateValue.status === types.AccountStatusEnum.EnableTradingWithoutConnected) && account5.stateValue.accountId) {
-        websocketClient.openPrivate(account5.stateValue.accountId);
-      }
-      account5.on("change:status", (nextState) => {
-        if ((nextState.status === types.AccountStatusEnum.EnableTrading || nextState.status === types.AccountStatusEnum.EnableTradingWithoutConnected) && nextState.accountId) {
-          websocketClient.openPrivate(nextState.accountId);
-        } else {
-          websocketClient.closePrivate(1e3, "switch account");
-        }
-      });
-      if (typeof window !== "undefined") {
-        utils.getGlobalObject()["__Orderly_WS"] = websocketClient;
-      }
-      core.SimpleDI.registerByName(WS_NAME, websocketClient);
-    }
-    return websocketClient;
-  });
-  return ws;
-};
 var useKeyStore = () => {
   const ctx = React.useContext(OrderlyContext);
   return ctx.keyStore;
@@ -742,6 +772,73 @@ var StatusProvider = (props) => {
   const wsStatus = useWsStatus();
   return /* @__PURE__ */ jsxRuntime.jsx(StatusContext.Provider, { value: { ws: wsStatus }, children: props.children });
 };
+var useWSObserver = (calculatorService) => {
+  const ws = useWS();
+  React.useEffect(() => {
+    const markPriceSubscription = ws.subscribe("markprices", {
+      onMessage: (message) => {
+        const data = /* @__PURE__ */ Object.create(null);
+        for (let index = 0; index < message.length; index++) {
+          const element = message[index];
+          data[element.symbol] = element.price;
+        }
+        calculatorService.calc("markPrice" /* MARK_PRICE */, data, {
+          skipWhenOnPause: true
+        });
+      },
+      onError: (error) => {
+      }
+    });
+    const indexPriceSubscription = ws.subscribe("indexprices", {
+      onMessage: (message) => {
+        if (!Array.isArray(message))
+          return;
+        const prices = /* @__PURE__ */ Object.create(null);
+        for (let index = 0; index < message.length; index++) {
+          const element = message[index];
+          prices[element.symbol.replace("SPOT", "PERP")] = element.price;
+        }
+        calculatorService.calc("indexPrice" /* INDEX_PRICE */, prices, {
+          skipWhenOnPause: true
+        });
+      }
+    });
+    return () => {
+      markPriceSubscription?.();
+      indexPriceSubscription?.();
+    };
+  }, []);
+};
+var useApiStatusStore = zustand.create()(
+  immer.immer((set) => ({
+    apis: {
+      positions: {
+        loading: false
+      }
+    },
+    actions: {
+      updateStatus: (key, status) => {
+        set((state) => {
+          state.apis[key] = status;
+        });
+      },
+      updateApiLoading: (key, loading) => {
+        set((state) => {
+          state.apis[key].loading = loading;
+        });
+      },
+      updateApiError: (key, error) => {
+        set((state) => {
+          state.apis[key] = {
+            loading: false,
+            error
+          };
+        });
+      }
+    }
+  }))
+);
+var useApiStatusActions = () => useApiStatusStore((state) => state.actions);
 var BaseMergeHandler = class {
   constructor(message) {
     this.message = message;
@@ -965,72 +1062,6 @@ var AlgoOrderMergeHandler = class _AlgoOrderMergeHandler extends BaseMergeHandle
     return rootOrder;
   }
 };
-
-// src/services/orderMerge/regularOrderMergeHandler.ts
-var RegularOrderMergeHandler = class extends BaseMergeHandler {
-  get orderId() {
-    return this.data.order_id;
-  }
-  get status() {
-    return this.data.status;
-  }
-  pre(message, prevData) {
-    return object2underscore(message);
-  }
-  isFullFilled() {
-    return "total_executed_quantity" in this.data && this.data.total_executed_quantity === this.data.quantity;
-  }
-};
-
-// src/utils/swr.ts
-var generateKeyFun = (args) => (pageIndex, previousPageData) => {
-  if (previousPageData && !previousPageData.rows?.length)
-    return null;
-  const { status, symbol, side, size = 100, page, dateRange } = args;
-  const search = new URLSearchParams([
-    ["size", size.toString()],
-    ["page", `${pageIndex + 1}`],
-    ["source_type", "ALL"]
-  ]);
-  if (dateRange) {
-    if (dateRange.from) {
-      search.set("start_t", `${dateRange.from.getTime()}`);
-    }
-    if (dateRange.to) {
-      search.set("end_t", `${dateRange.to.getTime()}`);
-    }
-  }
-  if (page) {
-    search.set("page", `${page}`);
-  }
-  if (status) {
-    search.set(`status`, status);
-  }
-  if (symbol) {
-    search.set(`symbol`, symbol);
-  }
-  if (side) {
-    search.set(`side`, side);
-  }
-  return `/v1/orders?${search.toString()}`;
-};
-var updateOrdersHandler = (key, updatedOrder, orders) => {
-  if (!orders) {
-    return;
-  }
-  const handler = new RegularOrderMergeHandler(updatedOrder);
-  return handler.merge(key, updatedOrder, orders);
-};
-function updateAlgoOrdersHandler(key, message, orders) {
-  if (!orders) {
-    return;
-  }
-  const mergeHandler = new AlgoOrderMergeHandler(message);
-  const result = mergeHandler.merge(key, message, orders);
-  return result;
-}
-function getPositionBySymbol(symbol) {
-}
 var useAppStore = zustand.create()(
   immer.immer((set) => ({
     // accountInfo: null,
@@ -1450,9 +1481,9 @@ var usePositionStore = zustand.create()(
       all: POSITION_EMPTY
     },
     actions: {
-      setPositions: (key, positions2) => {
+      setPositions: (key, positions3) => {
         set((state) => {
-          state.positions[key] = positions2;
+          state.positions[key] = positions3;
         });
       },
       closePosition: (symbol) => {
@@ -1472,36 +1503,6 @@ var usePositionStore = zustand.create()(
 );
 var usePositions = (symbol = "all") => usePositionStore((state) => (state.positions[symbol] ?? POSITION_EMPTY).rows);
 var usePositionActions = () => usePositionStore((state) => state.actions);
-var useApiStatusStore = zustand.create()(
-  immer.immer((set) => ({
-    apis: {
-      positions: {
-        loading: false
-      }
-    },
-    actions: {
-      updateStatus: (key, status) => {
-        set((state) => {
-          state.apis[key] = status;
-        });
-      },
-      updateApiLoading: (key, loading) => {
-        set((state) => {
-          state.apis[key].loading = loading;
-        });
-      },
-      updateApiError: (key, error) => {
-        set((state) => {
-          state.apis[key] = {
-            loading: false,
-            error
-          };
-        });
-      }
-    }
-  }))
-);
-var useApiStatusActions = () => useApiStatusStore((state) => state.actions);
 
 // src/orderly/calculator/positions.ts
 var NAME_PREFIX = "positionCalculator";
@@ -1537,38 +1538,41 @@ var PositionCalculator = class extends BaseCalculator {
     }
   }
   calcByMarkPrice(markPrice, ctx) {
-    let positions2 = this.getPosition(markPrice, ctx);
-    if (!positions2 || !Array.isArray(positions2.rows) || !positions2.rows.length)
-      return positions2;
-    positions2 = {
-      ...positions2,
-      rows: positions2.rows.map((item) => ({
-        ...item,
-        mark_price: markPrice[item.symbol] || item.mark_price
-      }))
+    let positions3 = this.getPosition(markPrice, ctx);
+    useAppStore.getState().fundingRates;
+    if (!positions3 || !Array.isArray(positions3.rows) || !positions3.rows.length)
+      return positions3;
+    positions3 = {
+      ...positions3,
+      rows: positions3.rows.map((item) => {
+        return {
+          ...item,
+          mark_price: markPrice[item.symbol] || item.mark_price
+        };
+      })
     };
-    return this.format(positions2, ctx);
+    return this.format(positions3, ctx);
   }
   calcByIndexPrice(indexPrice, ctx) {
-    let positions2 = this.getPosition(indexPrice, ctx);
-    if (!positions2) {
-      return positions2;
-    }
-    if (!Array.isArray(positions2.rows) || !positions2.rows.length)
-      return positions2;
-    positions2 = {
-      ...positions2,
-      rows: positions2.rows.map((item) => ({
+    let positions3 = this.getPosition(indexPrice, ctx);
+    if (!positions3) {
+      return positions3;
+    }
+    if (!Array.isArray(positions3.rows) || !positions3.rows.length)
+      return positions3;
+    positions3 = {
+      ...positions3,
+      rows: positions3.rows.map((item) => ({
         ...item,
         index_price: indexPrice[item.symbol] || item.index_price || item.mark_price
       }))
     };
-    return this.format(positions2, ctx);
+    return this.format(positions3, ctx);
   }
-  calcByPosition(positions2, ctx) {
-    if (positions2.rows.length === 0)
-      return positions2;
-    return this.format(positions2, ctx);
+  calcByPosition(positions3, ctx) {
+    if (positions3.rows.length === 0)
+      return positions3;
+    return this.format(positions3, ctx);
   }
   format(data, ctx) {
     const { accountInfo, symbolsInfo, fundingRates, portfolio } = ctx;
@@ -1578,6 +1582,7 @@ var PositionCalculator = class extends BaseCalculator {
     let unrealPnL_total = utils.zero, unrealPnL_total_index = utils.zero, notional_total = utils.zero, unsettlementPnL_total = utils.zero;
     let rows = data.rows.map((item) => {
       const info = symbolsInfo[item.symbol];
+      const sum_unitary_funding = fundingRates?.[item.symbol]?.["sum_unitary_funding"] ?? 0;
       const notional = perp.positions.notional(item.position_qty, item.mark_price);
       const unrealPnl = perp.positions.unrealizedPnL({
         qty: item.position_qty,
@@ -1636,8 +1641,10 @@ var PositionCalculator = class extends BaseCalculator {
       unrealPnL_total_index = unrealPnL_total_index.add(unrealPnl_index);
       notional_total = notional_total.add(notional);
       unsettlementPnL_total = unsettlementPnL_total.add(unsettlementPnL2);
+      const fundingFee = new utils.Decimal(sum_unitary_funding).sub(item.last_sum_unitary_funding).mul(item.position_qty).negated().toNumber();
       return {
         ...item,
+        fundingFee,
         mm: perp.positions.maintenanceMargin({
           positionQty: item.position_qty,
           markPrice: item.mark_price,
@@ -1706,12 +1713,12 @@ var PositionCalculator = class extends BaseCalculator {
     };
   }
   getPosition(_, ctx) {
-    let positions2 = ctx.get((output) => output[this.name]) || usePositionStore.getState().positions[this.symbol];
+    const positions3 = ctx.get((output) => output[this.name]) || usePositionStore.getState().positions[this.symbol];
     if (this.symbol === AllPositions) {
-      return positions2;
+      return positions3;
     }
-    if (positions2 && Array.isArray(positions2.rows)) {
-      return positions2;
+    if (positions3 && Array.isArray(positions3.rows)) {
+      return positions3;
     }
     return this.preprocess(this.getAllPositions(ctx));
   }
@@ -1726,25 +1733,6 @@ var PositionCalculator = class extends BaseCalculator {
 PositionCalculator.logPosition = (symbol = "all") => {
   return usePositionStore.getState().positions[symbol];
 };
-
-// src/utils/parseHolding.ts
-var parseHolding = (holding, markPrices) => {
-  const nonUSDC = [];
-  let USDC_holding = 0;
-  holding.forEach((item) => {
-    if (item.token === "USDC") {
-      USDC_holding = item.holding;
-    } else {
-      nonUSDC.push({
-        holding: item.holding,
-        markPrice: markPrices[item.token] ?? 0,
-        // markPrice: 0,
-        discount: 0
-      });
-    }
-  });
-  return [USDC_holding, nonUSDC];
-};
 function createGetter(data, depth = 2) {
   const getValue = (value, defaultValue) => {
     if (defaultValue === void 0) {
@@ -1775,6 +1763,25 @@ function createGetter(data, depth = 2) {
   });
 }
 
+// src/utils/parseHolding.ts
+var parseHolding = (holding, markPrices) => {
+  const nonUSDC = [];
+  let USDC_holding = 0;
+  holding.forEach((item) => {
+    if (item.token === "USDC") {
+      USDC_holding = item.holding;
+    } else {
+      nonUSDC.push({
+        holding: item.holding,
+        markPrice: markPrices[item.token] ?? 0,
+        // markPrice: 0,
+        discount: 0
+      });
+    }
+  });
+  return [USDC_holding, nonUSDC];
+};
+
 // src/orderly/calculator/portfolio.ts
 var PortfolioCalculatorName = "portfolio";
 var PortfolioCalculator = class extends BaseCalculator {
@@ -1783,7 +1790,7 @@ var PortfolioCalculator = class extends BaseCalculator {
     this.name = PortfolioCalculatorName;
   }
   calc(scope, data, ctx) {
-    let markPrices, positions2;
+    let markPrices, positions3;
     const portfolio = this.getPortfolio(ctx);
     if (scope === "markPrice" /* MARK_PRICE */) {
       markPrices = data;
@@ -1792,27 +1799,31 @@ var PortfolioCalculator = class extends BaseCalculator {
         (cache) => cache[MarketCalculatorName]
       );
     }
-    positions2 = ctx.get(
+    positions3 = ctx.get(
       (output) => output.positionCalculator_all
     );
     let holding = portfolio.holding;
     if (scope === "portfolio" /* PORTFOLIO */ && data.holding && Array.isArray(holding)) {
-      holding = holding.map((item) => {
-        if (data.holding[item.token]) {
-          return {
-            ...item,
-            holding: data.holding[item.token].holding,
-            frozen: data.holding[item.token].frozen
-          };
-        }
-        return item;
-      });
+      if (Array.isArray(data.holding)) {
+        holding = data.holding;
+      } else {
+        holding = holding.map((item) => {
+          if (data.holding[item.token]) {
+            return {
+              ...item,
+              holding: data.holding[item.token].holding,
+              frozen: data.holding[item.token].frozen
+            };
+          }
+          return item;
+        });
+      }
     }
     const accountInfo = ctx.accountInfo;
     const symbolsInfo = ctx.symbolsInfo;
     return this.format({
       holding,
-      positions: positions2,
+      positions: positions3,
       markPrices,
       accountInfo,
       symbolsInfo
@@ -1822,12 +1833,12 @@ var PortfolioCalculator = class extends BaseCalculator {
     return ctx.get((output) => output[this.name]) || useAppStore.getState().portfolio;
   }
   format(inputs) {
-    const { holding, positions: positions2, markPrices, accountInfo, symbolsInfo } = inputs;
-    if (!holding || !positions2 || !Array.isArray(positions2.rows) || !markPrices || !accountInfo) {
+    const { holding, positions: positions3, markPrices, accountInfo, symbolsInfo } = inputs;
+    if (!holding || !positions3 || !Array.isArray(positions3.rows) || !markPrices || !accountInfo) {
       return null;
     }
-    const unsettledPnL = ramda.pathOr(0, ["total_unsettled_pnl"])(positions2);
-    const unrealizedPnL = ramda.pathOr(0, ["total_unreal_pnl"])(positions2);
+    const unsettledPnL = ramda.pathOr(0, ["total_unsettled_pnl"])(positions3);
+    const unrealizedPnL = ramda.pathOr(0, ["total_unreal_pnl"])(positions3);
     const [USDC_holding, nonUSDC] = parseHolding(holding, markPrices);
     const usdc = holding.find((item) => item.token === "USDC");
     const totalCollateral = perp.account.totalCollateral({
@@ -1845,7 +1856,7 @@ var PortfolioCalculator = class extends BaseCalculator {
       totalValue: totalValue.toNumber()
     });
     const totalInitialMarginWithOrders = perp.account.totalInitialMarginWithQty({
-      positions: positions2.rows,
+      positions: positions3.rows,
       markPrices,
       IMR_Factors: accountInfo.imr_factor,
       maxLeverage: accountInfo.max_leverage,
@@ -1857,7 +1868,7 @@ var PortfolioCalculator = class extends BaseCalculator {
     });
     const availableBalance = perp.account.availableBalance({
       USDCHolding: usdc?.holding ?? 0,
-      unsettlementPnL: positions2.total_unsettled_pnl ?? 0
+      unsettlementPnL: positions3.total_unsettled_pnl ?? 0
     });
     return {
       totalCollateral,
@@ -1949,6 +1960,75 @@ var useCalculatorService = () => {
   return calculatorService;
 };
 
+// src/services/orderMerge/regularOrderMergeHandler.ts
+var RegularOrderMergeHandler = class extends BaseMergeHandler {
+  get orderId() {
+    return this.data.order_id;
+  }
+  get status() {
+    return this.data.status;
+  }
+  pre(message, prevData) {
+    return object2underscore(message);
+  }
+  isFullFilled() {
+    return "total_executed_quantity" in this.data && this.data.total_executed_quantity === this.data.quantity;
+  }
+};
+
+// src/utils/swr.ts
+var generateKeyFun = (url, args) => (pageIndex, previousPageData) => {
+  if (previousPageData && !previousPageData.rows?.length)
+    return null;
+  const { status, symbol, side, size = 100, page, dateRange } = args;
+  const search = new URLSearchParams([
+    ["size", size.toString()],
+    ["page", `${pageIndex + 1}`]
+    // ["source_type", "ALL"],
+  ]);
+  if (args.sourceTypeAll) {
+    search.set("source_type", "ALL");
+  }
+  if (dateRange) {
+    if (dateRange.from) {
+      search.set("start_t", `${dateRange.from.getTime()}`);
+    }
+    if (dateRange.to) {
+      search.set("end_t", `${dateRange.to.getTime()}`);
+    }
+  }
+  if (page) {
+    search.set("page", `${page}`);
+  }
+  if (status) {
+    search.set(`status`, status);
+  }
+  if (symbol) {
+    search.set(`symbol`, symbol);
+  }
+  if (side) {
+    search.set(`side`, side);
+  }
+  return `${url}?${search.toString()}`;
+};
+var updateOrdersHandler = (key, updatedOrder, orders) => {
+  if (!orders) {
+    return;
+  }
+  const handler = new RegularOrderMergeHandler(updatedOrder);
+  return handler.merge(key, updatedOrder, orders);
+};
+function updateAlgoOrdersHandler(key, message, orders) {
+  if (!orders) {
+    return;
+  }
+  const mergeHandler = new AlgoOrderMergeHandler(message);
+  const result = mergeHandler.merge(key, message, orders);
+  return result;
+}
+function getPositionBySymbol(symbol) {
+}
+
 // src/orderly/orderbook.service.ts
 var defaultRawOrderBook = {
   asks: [],
@@ -2071,10 +2151,10 @@ var useMarkPrice = (symbol) => {
 };
 var useSymbolsInfo = () => {
   const symbolsInfo = useAppStore((state) => state.symbolsInfo);
-  return React.useMemo(
-    () => createGetter({ ...symbolsInfo }),
-    [symbolsInfo]
-  );
+  return React.useMemo(() => createGetter({ ...symbolsInfo }), [symbolsInfo]);
+};
+var useSymbolsInfoStore = () => {
+  return useAppStore((state) => state.symbolsInfo);
 };
 var useIndexPrice = (symbol) => {
   symbol = symbol.replace("PERP", "SPOT");
@@ -2430,41 +2510,8 @@ var useOrderbookStream = (symbol, initial = INIT_DATA, options) => {
     bids: [...data.bids]
   });
   React.useEffect(() => {
-    const updateData = [
-      [
-        reducedData.asks?.[reducedData.asks.length - 1]?.[0],
-        reducedData.bids?.[0]?.[0]
-      ],
-      [
-        reducedData.asks?.[reducedData.asks.length - 2]?.[0],
-        reducedData.bids?.[1]?.[0]
-      ],
-      [
-        reducedData.asks?.[reducedData.asks.length - 3]?.[0],
-        reducedData.bids?.[2]?.[0]
-      ],
-      [
-        reducedData.asks?.[reducedData.asks.length - 4]?.[0],
-        reducedData.bids?.[3]?.[0]
-      ],
-      [
-        reducedData.asks?.[reducedData.asks.length - 5]?.[0],
-        reducedData.bids?.[4]?.[0]
-      ]
-    ];
-    eventEmitter.emit("orderbook:update", updateData);
-  }, [
-    reducedData.asks?.[reducedData.asks.length - 1]?.[0],
-    reducedData.asks?.[reducedData.asks.length - 2]?.[0],
-    reducedData.asks?.[reducedData.asks.length - 3]?.[0],
-    reducedData.asks?.[reducedData.asks.length - 4]?.[0],
-    reducedData.asks?.[reducedData.asks.length - 5]?.[0],
-    reducedData.bids?.[0]?.[0],
-    reducedData.bids?.[1]?.[0],
-    reducedData.bids?.[2]?.[0],
-    reducedData.bids?.[3]?.[0],
-    reducedData.bids?.[4]?.[0]
-  ]);
+    eventEmitter.emit("orderbook:update", reducedData);
+  }, [reducedData]);
   const middlePrice = React.useMemo(() => {
     let asksFrist = 0, bidsFirst = 0;
     if (data.asks.length > 0) {
@@ -2493,7 +2540,9 @@ var useOrderbookStream = (symbol, initial = INIT_DATA, options) => {
 
 // src/orderly/useAccountInfo.ts
 var useAccountInfo2 = () => {
-  return usePrivateQuery("/v1/client/info");
+  return usePrivateQuery("/v1/client/info", {
+    revalidateOnFocus: false
+  });
 };
 var useMarketsStream = () => {
   const ws = useWS();
@@ -2558,6 +2607,10 @@ var useFundingRates = () => {
   const data = useAppStore((state) => state.fundingRates);
   return createGetter({ ...data });
 };
+var useFundingRatesStore = () => {
+  const data = useAppStore((state) => state.fundingRates);
+  return data;
+};
 var DefaultTab = { name: "Popular", id: 1 };
 var marketsKey = "markets";
 var useMarket = (type) => {
@@ -3144,6 +3197,12 @@ var useMarkPricesStream = () => {
   const data = useMarkPriceStore((state) => state.markPrices);
   return { data };
 };
+
+// src/orderly/useIndexPricesStream.ts
+var useIndexPricesStream = () => {
+  const data = useIndexPriceStore((state) => state.indexPrices);
+  return { data };
+};
 var generateLeverageLevers = (max3) => {
   const min3 = 1;
   const parts = 5;
@@ -3155,8 +3214,11 @@ var generateLeverageLevers = (max3) => {
   return result;
 };
 var useLeverage = () => {
-  const { data, mutate: mutate3 } = usePrivateQuery(
-    "/v1/client/info"
+  const { data, mutate: mutate5 } = usePrivateQuery(
+    "/v1/client/info",
+    {
+      revalidateOnFocus: false
+    }
   );
   const [update, { isMutating }] = useMutation("/v1/client/leverage");
   const { data: leverageConfig, isLoading } = useQuery("/v1/public/leverage", {
@@ -3168,12 +3230,12 @@ var useLeverage = () => {
     async (data2) => {
       const res = await update(data2);
       if (res.success) {
-        return mutate3();
+        return mutate5();
       } else {
         throw new Error(res.message);
       }
     },
-    [update, mutate3]
+    [update, mutate5]
   );
   const memoizedCurLeverage = React.useMemo(() => {
     if (data?.max_leverage !== void 0) {
@@ -3324,6 +3386,11 @@ var findPositionTPSLFromOrders = (orders, symbol) => {
 };
 
 // src/orderly/usePositionStream/usePositionStream.ts
+var scopes = [
+  "position" /* POSITION */,
+  "markPrice" /* MARK_PRICE */,
+  "indexPrice" /* INDEX_PRICE */
+];
 var usePositionStream = (symbol = "all", options) => {
   const { calcMode } = options || {};
   const { includedPendingOrder = false } = options || {};
@@ -3344,49 +3411,34 @@ var usePositionStream = (symbol = "all", options) => {
     (state) => state.apis
   );
   React.useEffect(() => {
-    if (symbol === "all")
+    if (symbol === "all") {
       return;
+    }
     positionCalculator.current = new PositionCalculator(symbol);
-    calculatorService.register(
-      "position" /* POSITION */,
-      positionCalculator.current
-    );
-    calculatorService.register(
-      "markPrice" /* MARK_PRICE */,
-      positionCalculator.current
-    );
-    calculatorService.register(
-      "indexPrice" /* INDEX_PRICE */,
-      positionCalculator.current
-    );
+    for (const scope of scopes) {
+      calculatorService.register(scope, positionCalculator.current);
+    }
     return () => {
-      calculatorService.unregister(
-        "position" /* POSITION */,
-        positionCalculator.current
-      );
-      calculatorService.unregister(
-        "markPrice" /* MARK_PRICE */,
-        positionCalculator.current
-      );
-      calculatorService.unregister(
-        "indexPrice" /* INDEX_PRICE */,
-        positionCalculator.current
-      );
+      for (const scope of scopes) {
+        calculatorService.unregister(scope, positionCalculator.current);
+      }
     };
   }, [symbol]);
   const formattedPositions = usePositionStore((state) => {
-    const positions2 = state.positions[symbol] ?? POSITION_EMPTY;
-    return [positions2.rows, ramda.omit(["rows"], positions2)];
+    const positions3 = state.positions[symbol] ?? POSITION_EMPTY;
+    return [positions3.rows, ramda.omit(["rows"], positions3)];
   });
   const { totalCollateral, totalValue, totalUnrealizedROI } = useAppStore(
     (state) => state.portfolio
   );
   const aggregated = React.useMemo(() => {
-    let data = formattedPositions[1];
-    if (!data)
+    const data = formattedPositions[1];
+    if (!data) {
       return {};
-    if (calcMode === "markPrice")
+    }
+    if (calcMode === "markPrice") {
       return data;
+    }
     const { total_unreal_pnl_index, unrealPnlROI_index, ...rest } = data;
     return {
       ...rest,
@@ -3438,7 +3490,10 @@ var usePositionStream = (symbol = "all", options) => {
       });
     }
   }
-  const positionInfoGetter = createGetter(aggregated, 1);
+  const positionInfoGetter = createGetter(
+    aggregated,
+    1
+  );
   return [
     {
       rows,
@@ -3475,10 +3530,15 @@ var useOrderStream = (params, options) => {
     side,
     size = 50,
     page,
-    dateRange
+    dateRange,
+    sourceTypeAll
   } = params;
-  const [includes2, setIncludes] = React.useState(params.includes ?? ["ALL"]);
-  const [excludes, setExcludes] = React.useState(params.excludes ?? []);
+  const [includes2, setIncludes] = React.useState(
+    params.includes ?? ["ALL"]
+  );
+  const [excludes, setExcludes] = React.useState(
+    params.excludes ?? []
+  );
   const { data: markPrices } = useMarkPricesStream();
   const { registerKeyHandler, unregisterKeyHandler } = useDataCenterContext();
   const [
@@ -3499,38 +3559,63 @@ var useOrderStream = (params, options) => {
     doUpdateAlgoOrder,
     { error: updateAlgoOrderError, isMutating: updateAlgoMutating }
   ] = useMutation("/v1/algo/order", "PUT");
+  const normalOrderKeyFn = React.useMemo(() => {
+    return generateKeyFun("/v1/orders", {
+      status,
+      symbol,
+      side,
+      size,
+      page,
+      dateRange,
+      sourceTypeAll
+    });
+  }, [status, symbol, side, size, page, dateRange]);
+  const algoOrderKeyFn = React.useMemo(() => {
+    return sourceTypeAll ? null : generateKeyFun("/v1/algo/orders", {
+      status,
+      symbol,
+      side,
+      size: 100,
+      page,
+      dateRange
+    });
+  }, [status, symbol, side, dateRange, size]);
   React.useEffect(() => {
     const formatKey = (value) => value ? `:${value}` : "";
     const key = `orders${formatKey(status)}${formatKey(symbol)}${formatKey(
       side
     )}${formatKey(size.toString())}`;
-    registerKeyHandler?.(
-      key,
-      generateKeyFun({ status, symbol, side, size, page, dateRange })
-    );
+    registerKeyHandler?.(key, normalOrderKeyFn);
+    if (algoOrderKeyFn) {
+      registerKeyHandler?.(key.replace("orders", "algoOrders"), algoOrderKeyFn);
+    }
     return () => {
       if (!options?.stopOnUnmount)
         return;
       unregisterKeyHandler(key);
+      if (algoOrderKeyFn) {
+        unregisterKeyHandler(key.replace("orders", "algoOrders"));
+      }
     };
-  }, [status, symbol, side, size, page, dateRange, options?.keeplive]);
-  const ordersResponse = usePrivateInfiniteQuery(
-    generateKeyFun({ status, symbol, side, size, page, dateRange }),
-    {
-      initialSize: 1,
-      // revalidateFirstPage: false,
-      // onError: (err) => {
-      //   console.error("fetch failed::::", err);
-      // },
-      formatter: (data) => data,
-      revalidateOnFocus: false
-    }
-  );
+  }, [normalOrderKeyFn, options?.keeplive]);
+  const normalOrdersResponse = usePrivateInfiniteQuery(normalOrderKeyFn, {
+    initialSize: 1,
+    formatter: (data) => data,
+    revalidateOnFocus: false
+  });
+  const algoOrdersResponse = usePrivateInfiniteQuery(algoOrderKeyFn, {
+    formatter: (data) => data,
+    revalidateOnFocus: false
+  });
   const flattenOrders = React.useMemo(() => {
-    if (!ordersResponse.data) {
+    if (!normalOrdersResponse.data || !algoOrdersResponse.data && !sourceTypeAll) {
       return null;
     }
-    let orders2 = ordersResponse.data?.map((item) => item.rows)?.flat();
+    let orders2 = normalOrdersResponse.data?.map((item) => item.rows)?.flat();
+    if (algoOrdersResponse.data) {
+      const algoOrders = algoOrdersResponse.data?.map((item) => item.rows)?.flat();
+      orders2 = [...orders2, ...algoOrders];
+    }
     if (includes2.includes("ALL") && excludes.length === 0) {
       return orders2;
     }
@@ -3546,7 +3631,7 @@ var useOrderStream = (params, options) => {
       );
     }
     return orders2;
-  }, [ordersResponse.data, includes2, excludes]);
+  }, [normalOrdersResponse.data, algoOrdersResponse.data, includes2, excludes]);
   const orders = React.useMemo(() => {
     if (!flattenOrders) {
       return null;
@@ -3586,13 +3671,13 @@ var useOrderStream = (params, options) => {
       doCancelAllOrders(null),
       doCancelAllAlgoOrders(null, { algo_type: "STOP" })
     ]);
-  }, [ordersResponse.data]);
+  }, [normalOrdersResponse.data, algoOrdersResponse.data]);
   const cancelAllTPSLOrders = React.useCallback(() => {
     return cancelAlgoOrdersByTypes([
       types.AlgoOrderRootType.POSITIONAL_TP_SL,
       types.AlgoOrderRootType.TP_SL
     ]);
-  }, [ordersResponse.data]);
+  }, [algoOrdersResponse.data]);
   const _updateOrder = React.useCallback(
     (orderId, order, type) => {
       switch (type) {
@@ -3626,7 +3711,8 @@ var useOrderStream = (params, options) => {
             source: `SDK${version_default}`
           }).then((res) => {
             if (res.success) {
-              ordersResponse.mutate();
+              normalOrdersResponse.mutate();
+              algoOrdersResponse.mutate();
               return res;
             } else {
               throw new Error(res.message);
@@ -3655,7 +3741,6 @@ var useOrderStream = (params, options) => {
     return _cancelOrder(orderId, "algoOrder", symbol2);
   }, []);
   const loadMore = () => {
-    ordersResponse.setSize(ordersResponse.size + 1);
   };
   const cancelTPSLChildOrder = React.useCallback(
     (orderId, rootAlgoOrderId) => {
@@ -3684,14 +3769,18 @@ var useOrderStream = (params, options) => {
     []
   );
   const meta = React.useMemo(() => {
-    return ordersResponse.data?.[0]?.meta;
-  }, [ordersResponse.data?.[0]]);
+    return normalOrdersResponse.data?.[0]?.meta;
+  }, [normalOrdersResponse.data?.[0]]);
+  const refresh = React.useCallback(() => {
+    normalOrdersResponse.mutate();
+    algoOrdersResponse.mutate();
+  }, []);
   return [
     orders,
     {
       total,
-      isLoading: ordersResponse.isLoading,
-      refresh: ordersResponse.mutate,
+      isLoading: normalOrdersResponse.isLoading || algoOrdersResponse.isLoading,
+      refresh,
       loadMore,
       cancelAllOrders,
       cancelAllTPSLOrders,
@@ -3782,7 +3871,8 @@ var useCollateral = (options = { dp: 6 }) => {
     totalValue,
     freeCollateral,
     availableBalance,
-    unsettledPnL
+    unsettledPnL,
+    holding
   } = useAppStore((state) => state.portfolio);
   const accountInfo = useAppStore((state) => state.accountInfo);
   return {
@@ -3791,14 +3881,14 @@ var useCollateral = (options = { dp: 6 }) => {
     totalValue: totalValue?.toDecimalPlaces(dp).toNumber() ?? null,
     availableBalance,
     unsettledPnL,
-    accountInfo
+    accountInfo,
+    holding
     // @hidden
     // positions: positionsPath(positions),
   };
 };
 var useMaxQty = (symbol, side, reduceOnly = false) => {
-  const positions2 = usePositions();
-  const [orders] = useOrderStream({ status: types.OrderStatus.NEW, size: 500 });
+  const positions3 = usePositions();
   const accountInfo = useAccountInfo();
   const symbolInfo = useSymbolsInfo();
   const { totalCollateral } = useCollateral();
@@ -3807,7 +3897,7 @@ var useMaxQty = (symbol, side, reduceOnly = false) => {
     if (!symbol)
       return 0;
     const positionQty = perp.account.getQtyFromPositions(
-      positions2 === null ? [] : positions2,
+      positions3 === null ? [] : positions3,
       symbol
     );
     if (reduceOnly) {
@@ -3827,28 +3917,16 @@ var useMaxQty = (symbol, side, reduceOnly = false) => {
       }
       return 0;
     }
-    if (!markPrices || !markPrices[symbol] || !orders || !accountInfo)
+    if (!markPrices || !markPrices[symbol] || !accountInfo || !positions3)
       return 0;
     const getSymbolInfo = symbolInfo[symbol];
-    const filterAlgoOrders = orders.filter(
-      (item) => item.algo_order_id === void 0 || item.algo_type === "BRACKET"
-    );
-    const buyOrdersQty = perp.account.getQtyFromOrdersBySide(
-      filterAlgoOrders,
-      symbol,
-      types.OrderSide.BUY
-    );
-    const sellOrdersQty = perp.account.getQtyFromOrdersBySide(
-      filterAlgoOrders,
-      symbol,
-      types.OrderSide.SELL
-    );
-    const otherPositions = !Array.isArray(positions2) ? [] : positions2.filter((item) => item.symbol !== symbol);
-    const otherOrders = filterAlgoOrders.filter(
-      (item) => item.symbol !== symbol
+    const currentSymbolPosition = positions3.find(
+      (item) => item.symbol === symbol
     );
+    const buyOrdersQty = currentSymbolPosition?.pending_long_qty ?? 0;
+    const sellOrdersQty = currentSymbolPosition?.pending_short_qty ?? 0;
+    const otherPositions = !Array.isArray(positions3) ? [] : positions3.filter((item) => item.symbol !== symbol);
     const otherIMs = perp.account.otherIMs({
-      orders: otherOrders,
       positions: otherPositions,
       symbolInfo,
       markPrices,
@@ -3871,10 +3949,9 @@ var useMaxQty = (symbol, side, reduceOnly = false) => {
     });
   }, [
     symbol,
-    positions2,
+    positions3,
     reduceOnly,
     markPrices,
-    orders,
     accountInfo,
     symbolInfo,
     side,
@@ -3883,9 +3960,8 @@ var useMaxQty = (symbol, side, reduceOnly = false) => {
   return Math.max(maxQty, 0);
 };
 var useMarginRatio = () => {
-  const positions2 = usePositionStore((state2) => state2.positions.all);
-  const { rows } = positions2;
-  const { notional } = positions2;
+  const positions3 = usePositionStore((state2) => state2.positions.all);
+  const { rows, notional } = positions3;
   const { state } = useAccount();
   const { data: markPrices } = useMarkPricesStream();
   const { totalCollateral } = useCollateral();
@@ -3906,8 +3982,9 @@ var useMarginRatio = () => {
     return null;
   }, [marginRatio, state.status]);
   const mmr = React.useMemo(() => {
-    if (!rows || rows.length <= 0 || notional == null)
+    if (!rows || rows.length <= 0 || notional == null) {
       return null;
+    }
     let positionsMM = utils.zero;
     for (let index = 0; index < rows.length; index++) {
       const item = rows[index];
@@ -3926,7 +4003,8 @@ var TestNetWhiteList = [
   types.ARBITRUM_TESTNET_CHAINID,
   types.SOLANA_TESTNET_CHAINID,
   types.MONAD_TESTNET_CHAINID,
-  types.ABSTRACT_TESTNET_CHAINID
+  types.ABSTRACT_TESTNET_CHAINID,
+  types.BSC_TESTNET_CHAINID
 ];
 var testnetTokenFallback = types.TesntTokenFallback([
   types.ArbitrumSepoliaTokenInfo,
@@ -4192,7 +4270,7 @@ var useChain = (token) => {
 };
 var useHoldingStream = () => {
   const ws = useWS();
-  const { data, isLoading, mutate: mutate3 } = usePrivateQuery(
+  const { data, isLoading, mutate: mutate5 } = usePrivateQuery(
     "/v1/client/holding",
     {
       formatter: (data2) => {
@@ -4216,14 +4294,17 @@ var useHoldingStream = () => {
         onMessage: (data2) => {
           const holding = data2?.balances ?? {};
           if (holding) {
-            mutate3((prevData) => {
+            mutate5((prevData) => {
               return prevData?.map((item) => {
                 const token = holding[item.token];
-                return {
-                  ...item,
-                  frozen: token.frozen,
-                  holding: token.holding
-                };
+                if (token) {
+                  return {
+                    ...item,
+                    frozen: token.frozen,
+                    holding: token.holding
+                  };
+                }
+                return item;
               });
             });
             next(holding);
@@ -4242,7 +4323,7 @@ var useHoldingStream = () => {
 
 // src/orderly/useWithdraw.ts
 var useWithdraw = (options) => {
-  const { account: account5, state } = useAccount();
+  const { account: account7, state } = useAccount();
   const [isLoading, setIsLoading] = React.useState(false);
   const { unsettledPnL, availableBalance, freeCollateral } = useCollateral();
   const networkId = useConfig("networkId");
@@ -4288,10 +4369,11 @@ var useWithdraw = (options) => {
   }, [targetChain]);
   const withdraw = React.useCallback(
     (inputs) => {
-      return account5.assetsManager.withdraw(inputs).then((res) => {
+      return account7.assetsManager.withdraw({ ...inputs, decimals: 6 }).then((res) => {
         if (res.success) {
           track2(types.TrackerEventName.withdrawSuccess, {
             wallet: state?.connectWallet?.name,
+            // TODO: fix network name, befault is not pass srcChainId
             network: targetChain?.network_infos.name,
             quantity: inputs.amount
           });
@@ -4306,7 +4388,7 @@ var useWithdraw = (options) => {
         throw err;
       });
     },
-    [state, targetChain, state]
+    [state, targetChain, state, options?.decimals]
   );
   return {
     dst,
@@ -4322,14 +4404,13 @@ var useDeposit = (options) => {
   const networkId = useConfig("networkId");
   const [balanceRevalidating, setBalanceRevalidating] = React.useState(false);
   const [allowanceRevalidating, setAllowanceRevalidating] = React.useState(false);
-  useEventEmitter();
   const [_, { findByChainId }] = useChains(void 0);
   const [quantity, setQuantity] = React.useState("");
   const [depositFee, setDepositFee] = React.useState(0n);
   const [depositFeeRevalidating, setDepositFeeRevalidating] = React.useState(false);
   const [balance, setBalance] = React.useState("0");
   const [allowance, setAllowance] = React.useState("0");
-  const { account: account5, state } = useAccount();
+  const { account: account7, state } = useAccount();
   const { track: track2 } = useTrack();
   const prevAddress = React.useRef();
   const getBalanceListener = React.useRef();
@@ -4337,16 +4418,16 @@ var useDeposit = (options) => {
     let chain;
     if (networkId === "testnet") {
       chain = findByChainId(
-        utils.isTestnet(options?.srcChainId) ? options?.srcChainId : types.ARBITRUM_TESTNET_CHAINID
+        utils.isTestnet(options.srcChainId) ? options.srcChainId : types.ARBITRUM_TESTNET_CHAINID
       );
     } else {
-      chain = findByChainId(options?.srcChainId);
+      chain = findByChainId(options.srcChainId);
       if (!chain?.network_infos?.bridgeless) {
         chain = findByChainId(types.ARBITRUM_MAINNET_CHAINID);
       }
     }
     return chain;
-  }, [networkId, findByChainId, options?.srcChainId]);
+  }, [networkId, findByChainId, options.srcChainId]);
   const dst = React.useMemo(() => {
     const USDC = targetChain?.token_infos.find(
       (token) => token.symbol === "USDC"
@@ -4360,18 +4441,18 @@ var useDeposit = (options) => {
     };
   }, [targetChain]);
   const isNativeToken = React.useMemo(
-    () => types.isNativeTokenChecker(options?.address || ""),
-    [options?.address]
+    () => types.isNativeTokenChecker(options.address || ""),
+    [options.address]
   );
   const fetchBalanceHandler = React.useCallback(
     async (address, decimals) => {
       let balance2;
       if (!!address && types.isNativeTokenChecker(address)) {
-        balance2 = await account5.assetsManager.getNativeBalance({
+        balance2 = await account7.assetsManager.getNativeBalance({
           decimals
         });
       } else {
-        balance2 = await account5.assetsManager.getBalance(address, { decimals });
+        balance2 = await account7.assetsManager.getBalance(address, { decimals });
       }
       return balance2;
     },
@@ -4397,7 +4478,7 @@ var useDeposit = (options) => {
         continue;
       }
       tasks.push(
-        account5.assetsManager.getBalanceByAddress(token.address, {
+        account7.assetsManager.getBalanceByAddress(token.address, {
           decimals: token?.decimals
         })
       );
@@ -4414,7 +4495,7 @@ var useDeposit = (options) => {
     if (address && types.isNativeTokenChecker(address))
       return;
     prevAddress.current = key;
-    const allowance2 = await account5.assetsManager.getAllowance({
+    const allowance2 = await account7.assetsManager.getAllowance({
       address,
       vaultAddress,
       decimals
@@ -4429,7 +4510,7 @@ var useDeposit = (options) => {
     if (!address || types.isNativeTokenChecker(address))
       return;
     prevAddress.current = address;
-    const allowance2 = await account5.assetsManager.getAllowance({
+    const allowance2 = await account7.assetsManager.getAllowance({
       address,
       decimals
     });
@@ -4453,19 +4534,21 @@ var useDeposit = (options) => {
     if (state.status < types.AccountStatusEnum.Connected)
       return;
     setBalanceRevalidating(true);
-    queryBalance(options?.address, options?.decimals);
+    queryBalance(options.address, options.decimals);
     const params = {
-      address: options?.address,
-      decimals: options?.decimals
+      address: options.address,
+      decimals: options.decimals
     };
-    if (account5.walletAdapter?.chainNamespace === types.ChainNamespace.solana) {
-      setAllowance(account5.walletAdapter.formatUnits(types.MaxUint256));
+    if (account7.walletAdapter?.chainNamespace === types.ChainNamespace.solana) {
+      setAllowance(
+        account7.walletAdapter.formatUnits(types.MaxUint256, options.decimals)
+      );
       return;
     }
-    if (dst.chainId !== options?.srcChainId) {
+    if (dst.chainId !== options.srcChainId) {
       queryAllowance(params);
     } else {
-      if (dst.symbol !== options?.srcToken) {
+      if (dst.symbol !== options.srcToken) {
         queryAllowance(params);
       } else {
         getAllowanceByDefaultAddress(params);
@@ -4473,54 +4556,60 @@ var useDeposit = (options) => {
     }
   }, [
     state.status,
-    options?.address,
-    options?.srcChainId,
-    options?.srcToken,
-    options?.decimals,
-    account5.address,
+    options.address,
+    options.srcChainId,
+    options.srcToken,
+    options.decimals,
+    account7.address,
     dst.chainId,
     dst.symbol
   ]);
   const updateAllowanceWhenTxSuccess = React.useCallback(
     (txHash) => {
-      return account5.walletAdapter?.pollTransactionReceiptWithBackoff(txHash).then((receipt) => {
+      return account7.walletAdapter?.pollTransactionReceiptWithBackoff(txHash).then((receipt) => {
         if (receipt.status === 1) {
-          account5.assetsManager.getAllowance({ address: options?.address }).then((allowance2) => {
+          account7.assetsManager.getAllowance({ address: options.address }).then((allowance2) => {
             setAllowance(() => allowance2);
           });
         }
       });
     },
-    [account5, options?.address]
+    [account7, options.address]
   );
   const approve = React.useCallback(
     async (amount) => {
-      if (!options?.address) {
+      if (!options.address) {
         throw new types.SDKError("Address is required");
       }
-      return account5.assetsManager.approve({
+      return account7.assetsManager.approve({
         address: options.address,
-        amount
+        amount,
+        decimals: options.decimals
       }).then((res) => {
         return updateAllowanceWhenTxSuccess(res.hash);
       }).catch((e) => {
         throw e;
       });
     },
-    [account5, getAllowance, options?.address, dst]
+    [account7, getAllowance, options.address, options.decimals, dst]
   );
   const deposit = React.useCallback(async () => {
-    if (!options?.address) {
+    if (!options.address) {
       throw new types.SDKError("Address is required");
     }
-    const _allowance = await account5.assetsManager.getAllowance({
-      address: options?.address
+    const _allowance = await account7.assetsManager.getAllowance({
+      address: options.address,
+      decimals: options.decimals
     });
     setAllowance(() => _allowance);
     if (new utils.Decimal(quantity).greaterThan(_allowance)) {
       throw new types.SDKError("Insufficient allowance");
     }
-    return account5.assetsManager.deposit(quantity, depositFee).then((res) => {
+    return account7.assetsManager.deposit({
+      amount: quantity,
+      fee: depositFee,
+      decimals: options.decimals
+    }).then((res) => {
       track2(types.TrackerEventName.depositSuccess, {
         wallet: state?.connectWallet?.name,
         network: targetChain?.network_infos.name,
@@ -4537,15 +4626,22 @@ var useDeposit = (options) => {
       });
       throw e;
     });
-  }, [account5, fetchBalance, quantity, depositFee, options?.address]);
+  }, [
+    account7,
+    fetchBalance,
+    quantity,
+    depositFee,
+    options.address,
+    options.decimals
+  ]);
   const loopGetBalance = async () => {
     getBalanceListener.current && clearTimeout(getBalanceListener.current);
-    const time = account5.walletAdapter?.chainNamespace === types.ChainNamespace.solana ? 1e4 : 3e3;
+    const time = account7.walletAdapter?.chainNamespace === types.ChainNamespace.solana ? 1e4 : 3e3;
     getBalanceListener.current = setTimeout(async () => {
       try {
         const balance2 = await fetchBalanceHandler(
-          options?.address,
-          options?.decimals
+          options.address,
+          options.decimals
         );
         setBalance(balance2);
         loopGetBalance();
@@ -4555,12 +4651,13 @@ var useDeposit = (options) => {
   };
   const getDepositFee = React.useCallback(
     async (quantity2) => {
-      return account5.assetsManager.getDepositFee(
-        quantity2,
-        targetChain?.network_infos
-      );
+      return account7.assetsManager.getDepositFee({
+        amount: quantity2,
+        chain: targetChain?.network_infos,
+        decimals: options.decimals
+      });
     },
-    [account5, targetChain]
+    [account7, targetChain, options.decimals]
   );
   const enquiryDepositFee = React.useCallback(() => {
     if (isNaN(Number(quantity)) || !quantity || Number(quantity) === 0) {
@@ -4583,14 +4680,14 @@ var useDeposit = (options) => {
     enquiryDepositFee();
   }, [quantity]);
   React.useEffect(() => {
-    if (!options?.address) {
+    if (!options.address) {
       return;
     }
     loopGetBalance();
     return () => {
       getBalanceListener.current && clearTimeout(getBalanceListener.current);
     };
-  }, [options?.address, options?.decimals]);
+  }, [options.address, options.decimals]);
   return {
     /** orderly support chain dst */
     dst,
@@ -4613,62 +4710,188 @@ var useDeposit = (options) => {
     setQuantity
   };
 };
-var useWalletSubscription = (options) => {
-  const ws = useWS();
-  return useSWRSubscription__default.default("wallet", (_, { next }) => {
-    const unsubscribe = ws.privateSubscribe(
-      {
-        id: "wallet",
-        event: "subscribe",
-        topic: "wallet",
-        ts: Date.now()
-      },
-      {
-        onMessage: (data) => {
-          options?.onMessage?.(data);
-          next(null, data);
-        }
-      }
-    );
-    return () => unsubscribe();
-  });
-};
-var useSettleSubscription = (options) => {
-  const ws = useWS();
-  return useSWRSubscription__default.default("settle", (_, { next }) => {
-    const unsubscribe = ws.privateSubscribe(
-      {
-        id: "settle",
-        event: "subscribe",
-        topic: "settle",
-        ts: utils.getTimestamp()
-      },
-      {
-        onMessage: (data) => {
-          options?.onMessage?.(data);
-          next(data);
-        }
-      }
-    );
-    return () => unsubscribe();
-  });
-};
-var useSymbolPriceRange = (symbol, side, price) => {
-  const config = useSymbolsInfo();
-  const priceRange = config?.[symbol]("price_range");
-  const priceScrope = config?.[symbol]("price_scope");
-  const { data: prices } = useMarkPricesStream();
-  const markPrice = price || prices?.[symbol];
-  const range = React.useMemo(() => {
-    if (config === void 0 || markPrice === void 0) {
-      return void 0;
-    }
-    if (priceRange === void 0 || Number.isNaN(markPrice)) {
-      return void 0;
+var fetcher3 = (url, options) => {
+  const init2 = {
+    method: options.arg.method,
+    headers: {
+      ...options.arg.signature
     }
-    if (side === "BUY") {
-      return {
-        max: new utils.Decimal(markPrice).mul(1 + priceRange).toNumber(),
+  };
+  if (options.arg.data) {
+    init2.body = JSON.stringify(options.arg.data);
+  }
+  if (typeof options.arg.params === "object" && Object.keys(options.arg.params).length) {
+    const search = new URLSearchParams(options.arg.params);
+    url = `${url}?${search.toString()}`;
+  }
+  return net.mutate(url, init2);
+};
+var useSubAccountMutation = (url, method = "POST", options) => {
+  const { accountId, ...restOptions } = options || {};
+  const apiBaseUrl = useConfig("apiBaseUrl");
+  let fullUrl = url;
+  if (!url.startsWith("http")) {
+    fullUrl = `${apiBaseUrl}${url}`;
+  }
+  const account7 = useAccountInstance();
+  const { trigger, reset, data, error, isMutating } = useSWRMutation__default.default(
+    fullUrl,
+    // method === "POST" ? fetcher : deleteFetcher,
+    fetcher3,
+    restOptions
+  );
+  const mutation = React.useCallback(
+    async (data2, params, options2) => {
+      const { accountId: _accountId, ...restOptions2 } = options2 || {};
+      let newUrl = url;
+      if (typeof params === "object" && Object.keys(params).length) {
+        const search = new URLSearchParams(params);
+        newUrl = `${url}?${search.toString()}`;
+      }
+      const payload = {
+        method,
+        url: newUrl,
+        data: data2
+      };
+      const signer = account7.signer;
+      const signature = await signer.sign(payload, utils.getTimestamp());
+      return trigger(
+        {
+          data: data2,
+          params,
+          method,
+          signature: {
+            ...signature,
+            "orderly-account-id": accountId || _accountId || account7.accountId
+          }
+        },
+        restOptions2
+      );
+    },
+    [trigger, account7, accountId]
+  );
+  return [
+    mutation,
+    {
+      data,
+      error,
+      reset,
+      isMutating
+    }
+  ];
+};
+
+// src/orderly/useTransfer.ts
+var useTransfer = (options) => {
+  const { fromAccountId } = options || {};
+  const { unsettledPnL, availableBalance, freeCollateral, holding } = useCollateral();
+  const [doTransfer, { isMutating: submitting }] = useSubAccountMutation(
+    "/v1/internal_transfer",
+    "POST",
+    {
+      accountId: fromAccountId
+    }
+  );
+  const transfer = React.useCallback(
+    async (token, receivers) => {
+      return doTransfer({
+        token,
+        receiver_list: Array.isArray(receivers) ? receivers : [receivers]
+      }).then((res) => {
+        if (res.success) {
+          return res;
+        }
+        throw res;
+      }).catch((err) => {
+        throw err;
+      });
+    },
+    [doTransfer]
+  );
+  const maxAmount = React.useMemo(() => {
+    return freeCollateral;
+  }, [freeCollateral]);
+  const availableTransfer = React.useMemo(() => {
+    if (unsettledPnL < 0) {
+      return freeCollateral;
+    } else {
+      return freeCollateral - unsettledPnL;
+    }
+  }, [freeCollateral, unsettledPnL]);
+  return {
+    submitting,
+    transfer,
+    maxAmount,
+    unsettledPnL,
+    availableBalance,
+    availableTransfer,
+    holding
+  };
+};
+var useWalletSubscription = (options) => {
+  const ws = useWS();
+  const { state } = useAccount();
+  return useSWRSubscription__default.default(
+    state.accountId ? ["wallet", state.accountId] : null,
+    (_, { next }) => {
+      const unsubscribe = ws.privateSubscribe(
+        {
+          id: "wallet",
+          event: "subscribe",
+          topic: "wallet",
+          ts: Date.now()
+        },
+        {
+          onMessage: (data) => {
+            options?.onMessage?.(data);
+            next(null, data);
+          }
+        }
+      );
+      return () => unsubscribe();
+    }
+  );
+};
+var useSettleSubscription = (options) => {
+  const ws = useWS();
+  const { state } = useAccount();
+  return useSWRSubscription__default.default(
+    state.accountId ? ["settle", state.accountId] : null,
+    (_, { next }) => {
+      const unsubscribe = ws.privateSubscribe(
+        {
+          id: "settle",
+          event: "subscribe",
+          topic: "settle",
+          ts: utils.getTimestamp()
+        },
+        {
+          onMessage: (data) => {
+            options?.onMessage?.(data);
+            next(data);
+          }
+        }
+      );
+      return () => unsubscribe();
+    }
+  );
+};
+var useSymbolPriceRange = (symbol, side, price) => {
+  const config = useSymbolsInfo();
+  const priceRange = config?.[symbol]("price_range");
+  const priceScrope = config?.[symbol]("price_scope");
+  const { data: prices } = useMarkPricesStream();
+  const markPrice = price || prices?.[symbol];
+  const range = React.useMemo(() => {
+    if (config === void 0 || markPrice === void 0) {
+      return void 0;
+    }
+    if (priceRange === void 0 || Number.isNaN(markPrice)) {
+      return void 0;
+    }
+    if (side === "BUY") {
+      return {
+        max: new utils.Decimal(markPrice).mul(1 + priceRange).toNumber(),
         min: new utils.Decimal(markPrice).mul(1 - priceScrope).toNumber()
       };
     }
@@ -4679,341 +4902,94 @@ var useSymbolPriceRange = (symbol, side, price) => {
   }, [symbol, side, priceRange, markPrice]);
   return range;
 };
-function offsetToPrice(inputs) {
-  const { offset, entryPrice, orderType, orderSide } = inputs;
-  if (!offset)
-    return;
-  if (orderSide === types.OrderSide.BUY) {
-    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
-      return new utils.Decimal(entryPrice).add(new utils.Decimal(offset)).toNumber();
-    }
-    return new utils.Decimal(entryPrice).minus(new utils.Decimal(offset)).toNumber();
-  }
-  if (orderSide === types.OrderSide.SELL) {
-    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
-      return new utils.Decimal(entryPrice).minus(new utils.Decimal(offset)).toNumber();
+function getMinNotional(props) {
+  const { price, base_tick, qty, min_notional, base_dp, quote_dp, quote_tick } = props;
+  if (price !== void 0 && qty !== void 0 && min_notional !== void 0) {
+    try {
+      const calcNotional = new utils.Decimal(price).mul(new utils.Decimal(qty)).toNumber();
+      const notional = Number.parseFloat(`${min_notional}`);
+      if (calcNotional < notional) {
+        let minQty = new utils.Decimal(notional).div(price).toDecimalPlaces(base_dp, utils.Decimal.ROUND_DOWN).add(base_tick ?? 0);
+        if (base_tick && base_tick > 0) {
+          minQty = new utils.Decimal(
+            getRoundedDownDivision(minQty.toNumber(), base_tick)
+          );
+        }
+        const newMinNotional = minQty.mul(price).add(quote_tick ?? 0).toFixed(quote_dp);
+        return newMinNotional;
+      }
+    } catch (e) {
     }
-    return new utils.Decimal(entryPrice).add(new utils.Decimal(offset)).toNumber();
   }
 }
-function priceToOffset(inputs, options = {}) {
-  const { price, entryPrice, orderType, orderSide } = inputs;
-  const { symbol } = options;
-  let decimal;
-  if (orderSide === types.OrderSide.BUY) {
-    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
-      decimal = new utils.Decimal(price).minus(new utils.Decimal(entryPrice));
-    }
-    decimal = new utils.Decimal(price).minus(new utils.Decimal(entryPrice));
-  }
-  if (orderSide === types.OrderSide.SELL) {
-    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
-      decimal = new utils.Decimal(price).minus(new utils.Decimal(entryPrice));
+function checkNotional(props) {
+  const { price, base_tick, qty, min_notional, base_dp, quote_dp, quote_tick } = props;
+  if (price !== void 0 && qty !== void 0 && min_notional !== void 0) {
+    try {
+      const calcNotional = new utils.Decimal(price).mul(new utils.Decimal(qty)).toNumber();
+      const notional = Number.parseFloat(`${min_notional}`);
+      if (calcNotional < notional) {
+        let minQty = new utils.Decimal(notional).div(price).toDecimalPlaces(base_dp, utils.Decimal.ROUND_DOWN).add(base_tick ?? 0);
+        if (base_tick && base_tick > 0) {
+          minQty = new utils.Decimal(
+            getRoundedDownDivision(minQty.toNumber(), base_tick)
+          );
+        }
+        const newMinNotional = minQty.mul(price).add(quote_tick ?? 0).toFixed(quote_dp);
+        return `The order value should be greater or equal to ${newMinNotional} USDC`;
+      }
+      return void 0;
+    } catch (e) {
+      return void 0;
     }
-    decimal = new utils.Decimal(entryPrice).minus(new utils.Decimal(price));
-  }
-  if (symbol) {
-    return decimal.abs().todp(symbol.quote_dp, utils.Decimal.ROUND_UP).toNumber();
   }
-  return decimal.abs().toNumber();
+  return void 0;
 }
-function offsetPercentageToPrice(inputs) {
-  const { percentage, entryPrice, orderType, orderSide } = inputs;
-  if (!percentage)
-    return;
-  if (orderSide === types.OrderSide.BUY) {
-    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
-      return new utils.Decimal(1).add(new utils.Decimal(percentage)).mul(new utils.Decimal(entryPrice)).toNumber();
-    }
-    return new utils.Decimal(1).minus(new utils.Decimal(percentage)).mul(new utils.Decimal(entryPrice)).toNumber();
-  }
-  if (orderSide === types.OrderSide.SELL) {
-    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
-      return new utils.Decimal(1).minus(new utils.Decimal(percentage)).mul(new utils.Decimal(entryPrice)).toNumber();
-    }
-    return new utils.Decimal(1).add(new utils.Decimal(percentage)).mul(new utils.Decimal(entryPrice)).toNumber();
-  }
+function getRoundedDownDivision(value, tick) {
+  const decimalValue = new utils.Decimal(value);
+  const decimalTick = new utils.Decimal(tick);
+  const quotient = decimalValue.dividedToIntegerBy(decimalTick);
+  return quotient.mul(decimalTick).toNumber();
 }
-function priceToOffsetPercentage(inputs) {
-  const { price, entryPrice, orderType, orderSide } = inputs;
-  if (orderSide === types.OrderSide.BUY) {
-    if (entryPrice === 0)
-      return 0;
-    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
-      return new utils.Decimal(price).div(new utils.Decimal(entryPrice)).minus(1).toDecimalPlaces(4, utils.Decimal.ROUND_DOWN).toNumber();
+
+// src/services/orderCreator/orderValidation.ts
+var OrderValidation = class {
+  static getLabel(key) {
+    switch (key) {
+      case "quantity":
+      case "order_quantity":
+        return "Quantity";
+      case "order_price":
+        return "Price";
+      case "trigger_price":
+        return "Trigger price";
+      case "tp_trigger_price":
+        return "TP price";
+      case "sl_trigger_price":
+        return "SL price";
+      default:
+        return key;
     }
-    return new utils.Decimal(1).minus(new utils.Decimal(price).div(new utils.Decimal(entryPrice))).toDecimalPlaces(4, utils.Decimal.ROUND_DOWN).toNumber();
   }
-  if (orderSide === types.OrderSide.SELL) {
-    if (entryPrice === 0)
-      return 0;
-    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
-      return new utils.Decimal(1).minus(new utils.Decimal(price).div(new utils.Decimal(entryPrice))).abs().toDecimalPlaces(4, utils.Decimal.ROUND_DOWN).toNumber();
-    }
-    return new utils.Decimal(price).div(new utils.Decimal(entryPrice)).minus(1).toDecimalPlaces(4, utils.Decimal.ROUND_DOWN).toNumber();
+  static required(key) {
+    return {
+      type: "required",
+      message: `${this.getLabel(key)} is required`
+    };
   }
-}
-function pnlToPrice(inputs) {
-  const { qty, pnl, entryPrice, orderType, orderSide } = inputs;
-  if (!pnl) {
-    return;
+  static min(key, value) {
+    return {
+      type: "min",
+      message: `${this.getLabel(key)} must be greater than ${value}`,
+      value
+    };
   }
-  if (qty === 0)
-    return;
-  if (orderSide === types.OrderSide.BUY) {
-    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
-      return new utils.Decimal(entryPrice).plus(new utils.Decimal(pnl).div(new utils.Decimal(qty))).toNumber();
-    }
-    return new utils.Decimal(entryPrice).add(new utils.Decimal(pnl).div(new utils.Decimal(qty))).toNumber();
-  }
-  if (orderSide === types.OrderSide.SELL) {
-    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
-      return new utils.Decimal(entryPrice).add(new utils.Decimal(pnl).div(new utils.Decimal(qty))).toNumber();
-    }
-    return new utils.Decimal(entryPrice).add(new utils.Decimal(pnl).div(new utils.Decimal(qty))).toNumber();
-  }
-}
-function priceToPnl(inputs, options = {}) {
-  const { qty, price, entryPrice, orderType, orderSide } = inputs;
-  const { symbol } = options;
-  let decimal = utils.zero;
-  if (orderSide === types.OrderSide.BUY) {
-    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
-      decimal = new utils.Decimal(qty).mul(
-        new utils.Decimal(price).minus(new utils.Decimal(entryPrice))
-      );
-    }
-    decimal = new utils.Decimal(qty).mul(
-      new utils.Decimal(price).minus(new utils.Decimal(entryPrice))
-    );
-  }
-  if (orderSide === types.OrderSide.SELL) {
-    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
-      decimal = new utils.Decimal(qty).mul(
-        new utils.Decimal(price).minus(new utils.Decimal(entryPrice))
-      );
-    }
-    decimal = new utils.Decimal(qty).mul(
-      new utils.Decimal(price).minus(new utils.Decimal(entryPrice))
-    );
-  }
-  if (symbol) {
-    return decimal.todp(2, utils.Decimal.ROUND_DOWN).toNumber();
-  }
-  return decimal.toNumber();
-}
-function calcTPSL_ROI(inputs) {
-  const qtyNum = Number(inputs.qty);
-  const priceNum = Number(inputs.price);
-  if (qtyNum === 0 || priceNum === 0)
-    return "0";
-  return new utils.Decimal(inputs.pnl).div(new utils.Decimal(qtyNum).abs().mul(new utils.Decimal(priceNum))).toString();
-}
-function tpslCalculateHelper(key, inputs, options = {}) {
-  const { symbol } = options;
-  if (key !== "quantity" && key !== "tp_trigger_price" && key !== "sl_trigger_price" && key !== "tp_pnl" && key !== "sl_pnl" && key !== "tp_offset" && key !== "sl_offset" && key !== "tp_offset_percentage" && key !== "sl_offset_percentage") {
-    return {
-      [key]: inputs.value
-    };
-  }
-  const orderType = key.startsWith("tp_") ? types.AlgoOrderType.TAKE_PROFIT : types.AlgoOrderType.STOP_LOSS;
-  const keyPrefix = key.slice(0, 3);
-  let qty = Number(key === "quantity" ? inputs.value : inputs.qty);
-  if (qty === 0 && (key === "tp_pnl" || key === "sl_pnl" || key === "tp_trigger_price" || key === "sl_trigger_price")) {
-    return {
-      [`${keyPrefix}trigger_price`]: "",
-      // [`${keyPrefix}offset`]: "",
-      // [`${keyPrefix}offset_percentage`]: "",
-      [`${keyPrefix}pnl`]: "",
-      [key]: inputs.value
-    };
-  }
-  let trigger_price, offset, offset_percentage, pnl;
-  const entryPrice = new utils.Decimal(inputs.entryPrice).todp(options.symbol?.quote_dp ?? 2, utils.Decimal.ROUND_UP).toNumber();
-  switch (key) {
-    case "tp_trigger_price":
-    case "sl_trigger_price": {
-      trigger_price = inputs.value;
-      if (inputs.value === "") {
-        return {
-          [`${keyPrefix}trigger_price`]: trigger_price,
-          [`${keyPrefix}offset`]: "",
-          [`${keyPrefix}offset_percentage`]: "",
-          [`${keyPrefix}pnl`]: "",
-          [`${keyPrefix}ROI`]: ""
-        };
-      }
-      break;
-    }
-    case "tp_pnl":
-    case "sl_pnl": {
-      pnl = inputs.value;
-      trigger_price = pnlToPrice({
-        qty,
-        pnl: Number(inputs.value),
-        entryPrice,
-        orderSide: inputs.orderSide,
-        orderType
-      });
-      break;
-    }
-    case "tp_offset":
-    case "sl_offset": {
-      offset = inputs.value;
-      trigger_price = offsetToPrice({
-        offset: Number(inputs.value),
-        entryPrice,
-        orderSide: inputs.orderSide,
-        orderType: key === "tp_offset" ? types.AlgoOrderType.TAKE_PROFIT : types.AlgoOrderType.STOP_LOSS
-      });
-      break;
-    }
-    case "tp_offset_percentage":
-    case "sl_offset_percentage": {
-      offset_percentage = inputs.value;
-      trigger_price = offsetPercentageToPrice({
-        percentage: Number(`${inputs.value}`.replace(/\.0{0,2}$/, "")),
-        entryPrice,
-        orderSide: inputs.orderSide,
-        orderType
-      });
-      break;
-    }
-  }
-  if (!trigger_price)
-    return {
-      [`${keyPrefix}trigger_price`]: "",
-      [`${keyPrefix}offset`]: "",
-      [`${keyPrefix}offset_percentage`]: "",
-      [`${keyPrefix}pnl`]: "",
-      [`${keyPrefix}ROI`]: "",
-      [key]: inputs.value
-    };
-  return {
-    [`${keyPrefix}trigger_price`]: utils.todpIfNeed(
-      trigger_price,
-      symbol?.quote_dp ?? 2
-    ),
-    [`${keyPrefix}offset`]: offset ?? priceToOffset(
-      {
-        price: Number(trigger_price),
-        entryPrice,
-        orderSide: inputs.orderSide,
-        orderType
-      },
-      options
-    ),
-    [`${keyPrefix}offset_percentage`]: offset_percentage ?? priceToOffsetPercentage({
-      price: Number(trigger_price),
-      entryPrice,
-      orderSide: inputs.orderSide,
-      orderType
-    }),
-    [`${keyPrefix}pnl`]: pnl ?? priceToPnl(
-      {
-        qty,
-        price: Number(trigger_price),
-        entryPrice,
-        orderSide: inputs.orderSide,
-        orderType
-      },
-      options
-    )
-    // [`${keyPrefix}ROI`]: calcROI({
-    //   pnl: Number(pnl ?? 0),
-    //   qty,
-    //   price: Number(trigger_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) {
-    try {
-      const calcNotional = new utils.Decimal(price).mul(new utils.Decimal(qty)).toNumber();
-      const notional = Number.parseFloat(`${min_notional}`);
-      if (calcNotional < notional) {
-        let minQty = new utils.Decimal(notional).div(price).toDecimalPlaces(base_dp, utils.Decimal.ROUND_DOWN).add(base_tick ?? 0);
-        if (base_tick && base_tick > 0) {
-          minQty = new utils.Decimal(
-            getRoundedDownDivision(minQty.toNumber(), base_tick)
-          );
-        }
-        const newMinNotional = minQty.mul(price).add(quote_tick ?? 0).toFixed(quote_dp);
-        return newMinNotional;
-      }
-    } catch (e) {
-    }
-  }
-}
-function checkNotional(props) {
-  const { price, base_tick, qty, min_notional, base_dp, quote_dp, quote_tick } = props;
-  if (price !== void 0 && qty !== void 0 && min_notional !== void 0) {
-    try {
-      const calcNotional = new utils.Decimal(price).mul(new utils.Decimal(qty)).toNumber();
-      const notional = Number.parseFloat(`${min_notional}`);
-      if (calcNotional < notional) {
-        let minQty = new utils.Decimal(notional).div(price).toDecimalPlaces(base_dp, utils.Decimal.ROUND_DOWN).add(base_tick ?? 0);
-        if (base_tick && base_tick > 0) {
-          minQty = new utils.Decimal(
-            getRoundedDownDivision(minQty.toNumber(), base_tick)
-          );
-        }
-        const newMinNotional = minQty.mul(price).add(quote_tick ?? 0).toFixed(quote_dp);
-        return `The order value should be greater or equal to ${newMinNotional} USDC`;
-      }
-      return void 0;
-    } catch (e) {
-      return void 0;
-    }
-  }
-  return void 0;
-}
-function getRoundedDownDivision(value, tick) {
-  const decimalValue = new utils.Decimal(value);
-  const decimalTick = new utils.Decimal(tick);
-  const quotient = decimalValue.dividedToIntegerBy(decimalTick);
-  return quotient.mul(decimalTick).toNumber();
-}
-
-// src/services/orderCreator/orderValidation.ts
-var OrderValidation = class {
-  static getLabel(key) {
-    switch (key) {
-      case "quantity":
-      case "order_quantity":
-        return "Quantity";
-      case "order_price":
-        return "Price";
-      case "trigger_price":
-        return "Trigger price";
-      case "tp_trigger_price":
-        return "TP price";
-      case "sl_trigger_price":
-        return "SL price";
-      default:
-        return key;
-    }
-  }
-  static required(key) {
-    return {
-      type: "required",
-      message: `${this.getLabel(key)} is required`
-    };
-  }
-  static min(key, value) {
-    return {
-      type: "min",
-      message: `${this.getLabel(key)} must be greater than ${value}`,
-      value
-    };
-  }
-  static max(key, value) {
-    return {
-      type: "max",
-      message: `${this.getLabel(key)} must be less than ${value}`,
-      value
-    };
+  static max(key, value) {
+    return {
+      type: "max",
+      message: `${this.getLabel(key)} must be less than ${value}`,
+      value
+    };
   }
 };
 
@@ -5027,7 +5003,11 @@ var BaseOrderCreator = class {
       reduce_only: data.reduce_only,
       order_quantity: data.order_quantity,
       total: data.total
+      // slippage: data.slippage,
     };
+    if (data.order_type === types.OrderType.MARKET && !!data.slippage) {
+      order.slippage = new utils.Decimal(data.slippage).div(100).toNumber();
+    }
     if (data.visible_quantity === 0) {
       order.visible_quantity = data.visible_quantity;
     }
@@ -5226,7 +5206,21 @@ var MarketOrderCreator = class extends BaseOrderCreator {
     };
   }
   validate(values2, configs) {
-    return this.baseValidate(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;
+    });
   }
 };
 var { maxPrice, minPrice, scopePrice } = perp.order;
@@ -5915,7 +5909,634 @@ var OrderFactory = class {
         return new GeneralOrderCreator();
     }
   }
-};
+};
+function useSubAccountQuery(query, options) {
+  const { formatter, accountId, ...swrOptions } = options || {};
+  const { state, account: account7 } = useAccount();
+  const middleware = Array.isArray(options?.use) ? options?.use ?? [] : [];
+  return useSWR__namespace.default(
+    () => accountId && (state.status >= types.AccountStatusEnum.EnableTrading || state.status === types.AccountStatusEnum.EnableTradingWithoutConnected) ? [query, accountId] : null,
+    (url, init2) => {
+      return fetcher(url, init2, { formatter });
+    },
+    {
+      ...swrOptions,
+      use: [...middleware, signatureMiddleware2(account7, accountId)],
+      onError: () => {
+      }
+    }
+  );
+}
+function signatureMiddleware2(account7, accountId) {
+  const apiBaseUrl = useConfig("apiBaseUrl");
+  return (useSWRNext) => {
+    return (key, fetcher4, config) => {
+      try {
+        const extendedFetcher = async (args) => {
+          const url = Array.isArray(args) ? args[0] : args;
+          const fullUrl = `${apiBaseUrl}${url}`;
+          const signer = account7.signer;
+          const payload = {
+            method: "GET",
+            url
+          };
+          const signature = await signer.sign(payload, utils.getTimestamp());
+          return fetcher4(fullUrl, {
+            headers: {
+              ...signature,
+              "orderly-account-id": accountId
+            }
+          });
+        };
+        return useSWRNext(key, extendedFetcher, config);
+      } catch (e) {
+        throw e;
+      }
+    };
+  };
+}
+function formatPortfolio(inputs) {
+  const { holding, positions: positions3, markPrices, accountInfo, symbolsInfo } = inputs;
+  if (!holding || !positions3 || !Array.isArray(positions3.rows) || !markPrices || !accountInfo || symbolsInfo?.isNil) {
+    return null;
+  }
+  const unsettledPnL = ramda.pathOr(0, ["total_unsettled_pnl"])(positions3);
+  const unrealizedPnL = ramda.pathOr(0, ["total_unreal_pnl"])(positions3);
+  const [USDC_holding, nonUSDC] = parseHolding(holding, markPrices);
+  const usdc = holding.find((item) => item.token === "USDC");
+  const totalCollateral = perp.account.totalCollateral({
+    USDCHolding: USDC_holding,
+    nonUSDCHolding: nonUSDC,
+    unsettlementPnL: unsettledPnL
+  });
+  const totalValue = perp.account.totalValue({
+    totalUnsettlementPnL: unsettledPnL,
+    USDCHolding: USDC_holding,
+    nonUSDCHolding: nonUSDC
+  });
+  const totalUnrealizedROI = perp.account.totalUnrealizedROI({
+    totalUnrealizedPnL: unrealizedPnL,
+    totalValue: totalValue.toNumber()
+  });
+  const totalInitialMarginWithOrders = perp.account.totalInitialMarginWithQty({
+    positions: positions3.rows,
+    markPrices,
+    IMR_Factors: accountInfo.imr_factor,
+    maxLeverage: accountInfo.max_leverage,
+    symbolInfo: symbolsInfo
+  });
+  const freeCollateral = perp.account.freeCollateral({
+    totalCollateral,
+    totalInitialMarginWithOrders
+  });
+  const availableBalance = perp.account.availableBalance({
+    USDCHolding: usdc?.holding ?? 0,
+    unsettlementPnL: positions3.total_unsettled_pnl ?? 0
+  });
+  return {
+    totalCollateral,
+    totalValue,
+    totalUnrealizedROI,
+    freeCollateral,
+    availableBalance,
+    unsettledPnL,
+    holding
+  };
+}
+function formatPositions(data, accountInfo, symbolsInfo, fundingRates) {
+  if (!accountInfo || !fundingRates || !symbolsInfo) {
+    return data;
+  }
+  let unrealPnL_total = utils.zero, unrealPnL_total_index = utils.zero, notional_total = utils.zero, unsettlementPnL_total = utils.zero;
+  const rows = data.rows.map((item) => {
+    const info = symbolsInfo[item.symbol];
+    const notional = perp.positions.notional(item.position_qty, item.mark_price);
+    const unrealPnl = perp.positions.unrealizedPnL({
+      qty: item.position_qty,
+      openPrice: item?.average_open_price,
+      // markPrice: unRealizedPrice,
+      markPrice: item.mark_price
+    });
+    let unrealPnl_index = 0, unrealPnlROI_index = 0;
+    const imr = perp.account.IMR({
+      maxLeverage: accountInfo.max_leverage,
+      baseIMR: info?.("base_imr"),
+      IMR_Factor: accountInfo.imr_factor[item.symbol],
+      positionNotional: notional,
+      ordersNotional: 0,
+      IMR_factor_power: 4 / 5
+    });
+    const unrealPnlROI = perp.positions.unrealizedPnLROI({
+      positionQty: item.position_qty,
+      openPrice: item.average_open_price,
+      IMR: imr,
+      unrealizedPnL: unrealPnl
+    });
+    if (item.index_price) {
+      unrealPnl_index = perp.positions.unrealizedPnL({
+        qty: item.position_qty,
+        openPrice: item?.average_open_price,
+        // markPrice: unRealizedPrice,
+        markPrice: item.index_price
+      });
+      unrealPnlROI_index = perp.positions.unrealizedPnLROI({
+        positionQty: item.position_qty,
+        openPrice: item.average_open_price,
+        IMR: imr,
+        unrealizedPnL: unrealPnl_index
+      });
+    }
+    const unsettlementPnL2 = perp.positions.unsettlementPnL({
+      positionQty: item.position_qty,
+      markPrice: item.mark_price,
+      costPosition: item.cost_position,
+      sumUnitaryFunding: ramda.propOr(
+        0,
+        "sum_unitary_funding",
+        fundingRates?.[item.symbol]
+      ),
+      lastSumUnitaryFunding: item.last_sum_unitary_funding
+    });
+    const MMR = perp.positions.MMR({
+      baseMMR: info?.("base_mmr"),
+      baseIMR: info?.("base_imr"),
+      IMRFactor: accountInfo.imr_factor[item.symbol],
+      positionNotional: notional,
+      IMR_factor_power: 4 / 5
+    });
+    unrealPnL_total = unrealPnL_total.add(unrealPnl);
+    unrealPnL_total_index = unrealPnL_total_index.add(unrealPnl_index);
+    notional_total = notional_total.add(notional);
+    unsettlementPnL_total = unsettlementPnL_total.add(unsettlementPnL2);
+    return {
+      ...item,
+      mm: perp.positions.maintenanceMargin({
+        positionQty: item.position_qty,
+        markPrice: item.mark_price,
+        MMR
+      }),
+      mmr: MMR,
+      notional,
+      unsettlement_pnl: unsettlementPnL2,
+      unrealized_pnl: unrealPnl,
+      unrealized_pnl_index: unrealPnl_index,
+      unrealized_pnl_ROI: unrealPnlROI,
+      unrealized_pnl_ROI_index: unrealPnlROI_index
+    };
+  });
+  const totalUnrealPnl = unrealPnL_total.toNumber();
+  const totalUnrealPnl_index = unrealPnL_total_index.toNumber();
+  const unsettlementPnL = unsettlementPnL_total.toNumber();
+  return {
+    ...data,
+    unrealPnL: totalUnrealPnl,
+    total_unreal_pnl: totalUnrealPnl,
+    total_unreal_pnl_index: totalUnrealPnl_index,
+    notional: notional_total.toNumber(),
+    unsettledPnL: unsettlementPnL,
+    total_unsettled_pnl: unsettlementPnL,
+    rows
+  };
+}
+function calcByPrice(positions3, markPrice, indexPrice) {
+  if (!positions3 || !Array.isArray(positions3.rows) || !positions3.rows.length) {
+    return positions3;
+  }
+  return {
+    ...positions3,
+    rows: positions3.rows.map((item) => ({
+      ...item,
+      mark_price: markPrice?.[item.symbol] || item.mark_price,
+      index_price: indexPrice?.[item.symbol] || item.index_price || item.mark_price
+    }))
+  };
+}
+var useSubAccountWS = (options) => {
+  const { accountId } = options;
+  const { configStore } = React.useContext(OrderlyContext);
+  const { state, account: account7 } = useAccount();
+  const websocketClient = React.useRef(
+    new net.WS({
+      networkId: configStore.get("networkId"),
+      // not need to subscribe public socket
+      // publicUrl: configStore.get("publicWsUrl"),
+      privateUrl: configStore.get("privateWsUrl"),
+      onSigntureRequest: async () => {
+        const signer = account7.signer;
+        const timestamp = utils.getTimestamp();
+        const result = await signer.signText(timestamp.toString());
+        return { ...result, timestamp };
+      }
+    })
+  );
+  React.useEffect(() => {
+    if (accountId && (state.status === types.AccountStatusEnum.EnableTrading || state.status === types.AccountStatusEnum.EnableTradingWithoutConnected)) {
+      websocketClient.current.openPrivate(accountId);
+    }
+    return () => {
+      websocketClient.current.closePrivate(1e3, "switch account");
+    };
+  }, [accountId, state.status]);
+  return websocketClient.current;
+};
+
+// src/subAccount/useSubAccountDataObserver.ts
+var useSubAccountDataObserver = (accountId) => {
+  const ws = useSubAccountWS({ accountId });
+  const { data: markPrices } = useMarkPricesStream();
+  const { data: indexPrices } = useIndexPricesStream();
+  const symbolsInfo = useSymbolsInfo();
+  const fundingRates = useFundingRatesStore();
+  const [holding, setHolding] = React.useState([]);
+  const [positions3, setPositions] = React.useState(
+    POSITION_EMPTY
+  );
+  const [portfolio, setportfolio] = React.useState();
+  const { data: accountInfo } = useSubAccountQuery(
+    "/v1/client/info",
+    { accountId, revalidateOnFocus: false }
+  );
+  const { data: positionsInfo } = useSubAccountQuery(
+    "/v1/positions",
+    {
+      accountId,
+      formatter: (data) => data
+    }
+  );
+  const { data: holdingRes } = useSubAccountQuery(
+    "/v1/client/holding",
+    {
+      accountId,
+      formatter: (data) => data.holding
+    }
+  );
+  React.useEffect(() => {
+    const portfolio2 = formatPortfolio({
+      holding,
+      positions: positions3,
+      markPrices,
+      accountInfo,
+      symbolsInfo
+    });
+    setportfolio(portfolio2);
+  }, [holding, positions3, markPrices, accountInfo, symbolsInfo]);
+  React.useEffect(() => {
+    if (!positionsInfo)
+      return;
+    if (positionsInfo.rows?.length === 0) {
+      setPositions(positionsInfo);
+      return;
+    }
+    const _positionsInfo = calcByPrice(positionsInfo, markPrices, indexPrices);
+    const _positions = formatPositions(
+      _positionsInfo,
+      accountInfo,
+      symbolsInfo,
+      fundingRates
+    );
+    setPositions({
+      ..._positions,
+      rows: _positions.rows.filter(
+        (item) => item.position_qty !== 0 || item.pending_long_qty !== 0 || item.pending_short_qty !== 0
+      )
+    });
+  }, [
+    positionsInfo,
+    accountInfo,
+    symbolsInfo,
+    fundingRates,
+    markPrices,
+    indexPrices
+  ]);
+  React.useEffect(() => {
+    if (holdingRes) {
+      setHolding(holdingRes);
+    }
+  }, [holdingRes]);
+  React.useEffect(() => {
+    if (!accountId)
+      return;
+    const unsubscribe = ws.privateSubscribe(
+      {
+        id: "balance",
+        event: "subscribe",
+        topic: "balance",
+        ts: Date.now()
+      },
+      {
+        onMessage: (data) => {
+          const holding2 = data?.balances ?? {};
+          setHolding((prev) => {
+            return prev.map((item) => {
+              if (holding2[item.token]) {
+                return { ...item, holding: holding2[item.token].holding };
+              }
+              return item;
+            });
+          });
+        }
+      }
+    );
+    return () => unsubscribe?.();
+  }, [accountId]);
+  React.useEffect(() => {
+    if (!accountId)
+      return;
+    const key = ["/v1/positions", accountId];
+    const unsubscribe = ws.privateSubscribe("position", {
+      onMessage: (data) => {
+        const { positions: nextPositions } = data;
+        useSWR.mutate(
+          key,
+          (prevPositions) => {
+            if (!!prevPositions) {
+              const newPositions = {
+                ...prevPositions,
+                rows: prevPositions.rows.map((row) => {
+                  const itemIndex = nextPositions.findIndex(
+                    (item) => item.symbol === row.symbol
+                  );
+                  if (itemIndex >= 0) {
+                    const itemArr = nextPositions.splice(itemIndex, 1);
+                    const item = itemArr[0];
+                    if (item.averageOpenPrice === 0 && item.positionQty !== 0) {
+                      return row;
+                    }
+                    return object2underscore(item);
+                  }
+                  return row;
+                })
+              };
+              if (nextPositions.length > 0) {
+                newPositions.rows = [
+                  ...newPositions.rows,
+                  ...nextPositions.map((item) => {
+                    return object2underscore(item);
+                  })
+                ];
+              }
+              return newPositions;
+            }
+          },
+          {
+            revalidate: false
+          }
+        );
+      }
+    });
+    return () => unsubscribe?.();
+  }, [accountId]);
+  return { portfolio, positions: positions3 };
+};
+function offsetToPrice(inputs) {
+  const { offset, entryPrice, orderType, orderSide } = inputs;
+  if (!offset)
+    return;
+  if (orderSide === types.OrderSide.BUY) {
+    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
+      return new utils.Decimal(entryPrice).add(new utils.Decimal(offset)).toNumber();
+    }
+    return new utils.Decimal(entryPrice).minus(new utils.Decimal(offset)).toNumber();
+  }
+  if (orderSide === types.OrderSide.SELL) {
+    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
+      return new utils.Decimal(entryPrice).minus(new utils.Decimal(offset)).toNumber();
+    }
+    return new utils.Decimal(entryPrice).add(new utils.Decimal(offset)).toNumber();
+  }
+}
+function priceToOffset(inputs, options = {}) {
+  const { price, entryPrice, orderType, orderSide } = inputs;
+  const { symbol } = options;
+  let decimal;
+  if (orderSide === types.OrderSide.BUY) {
+    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
+      decimal = new utils.Decimal(price).minus(new utils.Decimal(entryPrice));
+    }
+    decimal = new utils.Decimal(price).minus(new utils.Decimal(entryPrice));
+  }
+  if (orderSide === types.OrderSide.SELL) {
+    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
+      decimal = new utils.Decimal(price).minus(new utils.Decimal(entryPrice));
+    }
+    decimal = new utils.Decimal(entryPrice).minus(new utils.Decimal(price));
+  }
+  if (symbol) {
+    return decimal.abs().todp(symbol.quote_dp, utils.Decimal.ROUND_UP).toNumber();
+  }
+  return decimal.abs().toNumber();
+}
+function offsetPercentageToPrice(inputs) {
+  const { percentage, entryPrice, orderType, orderSide } = inputs;
+  if (!percentage)
+    return;
+  if (orderSide === types.OrderSide.BUY) {
+    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
+      return new utils.Decimal(1).add(new utils.Decimal(percentage)).mul(new utils.Decimal(entryPrice)).toNumber();
+    }
+    return new utils.Decimal(1).minus(new utils.Decimal(percentage)).mul(new utils.Decimal(entryPrice)).toNumber();
+  }
+  if (orderSide === types.OrderSide.SELL) {
+    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
+      return new utils.Decimal(1).minus(new utils.Decimal(percentage)).mul(new utils.Decimal(entryPrice)).toNumber();
+    }
+    return new utils.Decimal(1).add(new utils.Decimal(percentage)).mul(new utils.Decimal(entryPrice)).toNumber();
+  }
+}
+function priceToOffsetPercentage(inputs) {
+  const { price, entryPrice, orderType, orderSide } = inputs;
+  if (orderSide === types.OrderSide.BUY) {
+    if (entryPrice === 0)
+      return 0;
+    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
+      return new utils.Decimal(price).div(new utils.Decimal(entryPrice)).minus(1).toDecimalPlaces(4, utils.Decimal.ROUND_DOWN).toNumber();
+    }
+    return new utils.Decimal(1).minus(new utils.Decimal(price).div(new utils.Decimal(entryPrice))).toDecimalPlaces(4, utils.Decimal.ROUND_DOWN).toNumber();
+  }
+  if (orderSide === types.OrderSide.SELL) {
+    if (entryPrice === 0)
+      return 0;
+    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
+      return new utils.Decimal(1).minus(new utils.Decimal(price).div(new utils.Decimal(entryPrice))).abs().toDecimalPlaces(4, utils.Decimal.ROUND_DOWN).toNumber();
+    }
+    return new utils.Decimal(price).div(new utils.Decimal(entryPrice)).minus(1).toDecimalPlaces(4, utils.Decimal.ROUND_DOWN).toNumber();
+  }
+}
+function pnlToPrice(inputs) {
+  const { qty, pnl, entryPrice, orderType, orderSide } = inputs;
+  if (!pnl) {
+    return;
+  }
+  if (qty === 0)
+    return;
+  if (orderSide === types.OrderSide.BUY) {
+    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
+      return new utils.Decimal(entryPrice).plus(new utils.Decimal(pnl).div(new utils.Decimal(qty))).toNumber();
+    }
+    return new utils.Decimal(entryPrice).add(new utils.Decimal(pnl).div(new utils.Decimal(qty))).toNumber();
+  }
+  if (orderSide === types.OrderSide.SELL) {
+    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
+      return new utils.Decimal(entryPrice).add(new utils.Decimal(pnl).div(new utils.Decimal(qty))).toNumber();
+    }
+    return new utils.Decimal(entryPrice).add(new utils.Decimal(pnl).div(new utils.Decimal(qty))).toNumber();
+  }
+}
+function priceToPnl(inputs, options = {}) {
+  const { qty, price, entryPrice, orderType, orderSide } = inputs;
+  const { symbol } = options;
+  let decimal = utils.zero;
+  if (orderSide === types.OrderSide.BUY) {
+    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
+      decimal = new utils.Decimal(qty).mul(
+        new utils.Decimal(price).minus(new utils.Decimal(entryPrice))
+      );
+    }
+    decimal = new utils.Decimal(qty).mul(
+      new utils.Decimal(price).minus(new utils.Decimal(entryPrice))
+    );
+  }
+  if (orderSide === types.OrderSide.SELL) {
+    if (orderType === types.AlgoOrderType.TAKE_PROFIT) {
+      decimal = new utils.Decimal(qty).mul(
+        new utils.Decimal(price).minus(new utils.Decimal(entryPrice))
+      );
+    }
+    decimal = new utils.Decimal(qty).mul(
+      new utils.Decimal(price).minus(new utils.Decimal(entryPrice))
+    );
+  }
+  if (symbol) {
+    return decimal.todp(2, utils.Decimal.ROUND_DOWN).toNumber();
+  }
+  return decimal.toNumber();
+}
+function calcTPSL_ROI(inputs) {
+  const qtyNum = Number(inputs.qty);
+  const priceNum = Number(inputs.price);
+  if (qtyNum === 0 || priceNum === 0)
+    return "0";
+  return new utils.Decimal(inputs.pnl).div(new utils.Decimal(qtyNum).abs().mul(new utils.Decimal(priceNum))).toString();
+}
+function tpslCalculateHelper(key, inputs, options = {}) {
+  const { symbol } = options;
+  if (key !== "quantity" && key !== "tp_trigger_price" && key !== "sl_trigger_price" && key !== "tp_pnl" && key !== "sl_pnl" && key !== "tp_offset" && key !== "sl_offset" && key !== "tp_offset_percentage" && key !== "sl_offset_percentage") {
+    return {
+      [key]: inputs.value
+    };
+  }
+  const orderType = key.startsWith("tp_") ? types.AlgoOrderType.TAKE_PROFIT : types.AlgoOrderType.STOP_LOSS;
+  const keyPrefix = key.slice(0, 3);
+  let qty = Number(key === "quantity" ? inputs.value : inputs.qty);
+  if (qty === 0 && (key === "tp_pnl" || key === "sl_pnl" || key === "tp_trigger_price" || key === "sl_trigger_price")) {
+    return {
+      [`${keyPrefix}trigger_price`]: "",
+      // [`${keyPrefix}offset`]: "",
+      // [`${keyPrefix}offset_percentage`]: "",
+      [`${keyPrefix}pnl`]: "",
+      [key]: inputs.value
+    };
+  }
+  let trigger_price, offset, offset_percentage, pnl;
+  const entryPrice = new utils.Decimal(inputs.entryPrice).todp(options.symbol?.quote_dp ?? 2, utils.Decimal.ROUND_UP).toNumber();
+  switch (key) {
+    case "tp_trigger_price":
+    case "sl_trigger_price": {
+      trigger_price = inputs.value;
+      if (inputs.value === "") {
+        return {
+          [`${keyPrefix}trigger_price`]: trigger_price,
+          [`${keyPrefix}offset`]: "",
+          [`${keyPrefix}offset_percentage`]: "",
+          [`${keyPrefix}pnl`]: "",
+          [`${keyPrefix}ROI`]: ""
+        };
+      }
+      break;
+    }
+    case "tp_pnl":
+    case "sl_pnl": {
+      pnl = inputs.value;
+      trigger_price = pnlToPrice({
+        qty,
+        pnl: Number(inputs.value),
+        entryPrice,
+        orderSide: inputs.orderSide,
+        orderType
+      });
+      break;
+    }
+    case "tp_offset":
+    case "sl_offset": {
+      offset = inputs.value;
+      trigger_price = offsetToPrice({
+        offset: Number(inputs.value),
+        entryPrice,
+        orderSide: inputs.orderSide,
+        orderType: key === "tp_offset" ? types.AlgoOrderType.TAKE_PROFIT : types.AlgoOrderType.STOP_LOSS
+      });
+      break;
+    }
+    case "tp_offset_percentage":
+    case "sl_offset_percentage": {
+      offset_percentage = inputs.value;
+      trigger_price = offsetPercentageToPrice({
+        percentage: Number(`${inputs.value}`.replace(/\.0{0,2}$/, "")),
+        entryPrice,
+        orderSide: inputs.orderSide,
+        orderType
+      });
+      break;
+    }
+  }
+  if (!trigger_price)
+    return {
+      [`${keyPrefix}trigger_price`]: "",
+      [`${keyPrefix}offset`]: "",
+      [`${keyPrefix}offset_percentage`]: "",
+      [`${keyPrefix}pnl`]: "",
+      [`${keyPrefix}ROI`]: "",
+      [key]: inputs.value
+    };
+  return {
+    [`${keyPrefix}trigger_price`]: utils.todpIfNeed(
+      trigger_price,
+      symbol?.quote_dp ?? 2
+    ),
+    [`${keyPrefix}offset`]: offset ?? priceToOffset(
+      {
+        price: Number(trigger_price),
+        entryPrice,
+        orderSide: inputs.orderSide,
+        orderType
+      },
+      options
+    ),
+    [`${keyPrefix}offset_percentage`]: offset_percentage ?? priceToOffsetPercentage({
+      price: Number(trigger_price),
+      entryPrice,
+      orderSide: inputs.orderSide,
+      orderType
+    }),
+    [`${keyPrefix}pnl`]: pnl ?? priceToPnl(
+      {
+        qty,
+        price: Number(trigger_price),
+        entryPrice,
+        orderSide: inputs.orderSide,
+        orderType
+      },
+      options
+    )
+    // [`${keyPrefix}ROI`]: calcROI({
+    //   pnl: Number(pnl ?? 0),
+    //   qty,
+    //   price: Number(trigger_price!),
+    // }),
+  };
+}
+
+// src/orderly/useTakeProfitAndStopLoss/useTPSL.ts
 var useTaskProfitAndStopLossInternal = (position, options) => {
   const isEditing = typeof options?.isEditing !== "undefined" ? options.isEditing : !!options?.defaultOrder;
   const [order, setOrder] = React.useState({
@@ -5929,11 +6550,8 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
   });
   const symbolInfo = useSymbolsInfo()[position.symbol]();
   const { data: markPrice } = useMarkPrice(order.symbol);
-  const [doCreateOrder, { isMutating: isCreateMutating }] = useMutation("/v1/algo/order");
-  const [doUpdateOrder, { isMutating: isUpdateMutating }] = useMutation(
-    "/v1/algo/order",
-    "PUT"
-  );
+  const [doCreateOrder, { isMutating: isCreateMutating }] = useSubAccountMutation("/v1/algo/order");
+  const [doUpdateOrder, { isMutating: isUpdateMutating }] = useSubAccountMutation("/v1/algo/order", "PUT");
   const [doDeleteOrder] = useMutation("/v1/algo/order", "DELETE");
   const [errors, setErrors] = React.useState(null);
   React.useEffect(() => {
@@ -6049,22 +6667,22 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
       compare() ? types.AlgoOrderRootType.POSITIONAL_TP_SL : types.AlgoOrderRootType.TP_SL
     );
   };
-  const submit = async () => {
+  const submit = async (params) => {
     const defaultOrder = options?.defaultOrder;
     const orderId = defaultOrder?.algo_order_id;
     const algoType = defaultOrder?.algo_type;
     if (!orderId) {
-      return createOrder();
+      return createOrder(params);
     }
     if (algoType === types.AlgoOrderRootType.POSITIONAL_TP_SL) {
       if (compare()) {
-        return updateOrder(orderId);
+        return updateOrder(orderId, params);
       }
-      return createOrder();
+      return createOrder(params);
     }
-    return updateOrder(orderId);
+    return updateOrder(orderId, params);
   };
-  const createOrder = () => {
+  const createOrder = (params) => {
     const orderCreator = getOrderCreator2();
     const orderBody = orderCreator.create(
       order,
@@ -6076,7 +6694,7 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
     orderBody.child_orders = orderBody.child_orders.filter(
       (order2) => order2.is_activated
     );
-    return doCreateOrder(orderBody);
+    return doCreateOrder(orderBody, {}, params);
   };
   const deleteOrder = (orderId, symbol) => {
     return doDeleteOrder(null, {
@@ -6084,7 +6702,7 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
       symbol
     });
   };
-  const updateOrder = (orderId) => {
+  const updateOrder = (orderId, params) => {
     const orderCreator = getOrderCreator2();
     const [updatedOrderEntity, orderEntity] = orderCreator.crateUpdateOrder(
       // @ts-ignore
@@ -6101,10 +6719,14 @@ var useTaskProfitAndStopLossInternal = (position, options) => {
     if (needDelete) {
       return deleteOrder(orderId, order.symbol);
     }
-    return doUpdateOrder({
-      order_id: orderId,
-      ...updatedOrderEntity
-    });
+    return doUpdateOrder(
+      {
+        order_id: orderId,
+        ...updatedOrderEntity
+      },
+      {},
+      params
+    );
   };
   return [
     ramda.omit(["ignoreValidate"], order),
@@ -6147,6 +6769,7 @@ var useSymbolLeverage = (symbol) => {
   const maxAccountLeverage = info?.max_leverage;
   const res = useQuery(`/v1/public/info/${symbol}`, {
     dedupingInterval: 1e3 * 60 * 60 * 24,
+    // 24 hours
     revalidateOnFocus: false,
     errorRetryCount: 2,
     errorRetryInterval: 200
@@ -6188,7 +6811,7 @@ var useAssetsHistory = (options) => {
       searchParams.set("end_t", options.endTime);
     return `/v1/asset/history?${searchParams.toString()}`;
   };
-  const { data, isLoading, mutate: mutate3 } = usePrivateQuery(
+  const { data, isLoading, mutate: mutate5 } = usePrivateQuery(
     getKey(),
     {
       formatter: (data2) => data2,
@@ -6198,7 +6821,7 @@ var useAssetsHistory = (options) => {
   );
   const updateList = useDebounce.useDebouncedCallback(
     (data2) => {
-      mutate3();
+      mutate5();
     },
     // delay in ms
     300
@@ -6320,7 +6943,7 @@ var useFundingFeeHistory = (params, options) => {
   ];
 };
 var useDistributionHistory = (parmas) => {
-  let { type, dataRange, page, pageSize } = parmas;
+  const { type, dataRange, page, pageSize } = parmas;
   const infos = useSymbolsInfo();
   const getKey = () => {
     const search = new URLSearchParams();
@@ -6353,14 +6976,39 @@ var useDistributionHistory = (parmas) => {
       };
     });
   }, [data, infos]);
-  return [
-    parsedData,
+  return [parsedData, { meta: data?.meta, isLoading, isValidating }];
+};
+var useTransferHistory = (parmas) => {
+  const { dataRange, page, size, side, fromId, toId } = parmas;
+  const infos = useSymbolsInfo();
+  const memoizedQueryKey = React__default.default.useMemo(() => {
+    const search = new URLSearchParams();
+    search.set("page", page.toString());
+    search.set("size", size.toString());
+    search.set("side", side);
+    search.set("main_sub_only", `${true}`);
+    if (dataRange) {
+      search.set("start_t", dataRange[0].toString());
+      search.set("end_t", dataRange[1].toString());
+    }
+    return `/v1/internal_transfer_history?${search.toString()}`;
+  }, [page, size, fromId, toId, dataRange]);
+  const { data, isLoading } = usePrivateQuery(
+    memoizedQueryKey,
     {
-      meta: data?.meta,
-      isLoading,
-      isValidating
+      // initialSize: 1,
+      formatter: (data2) => data2,
+      revalidateOnFocus: false,
+      errorRetryCount: 3
     }
-  ];
+  );
+  const parsedData = React__default.default.useMemo(() => {
+    if (!Array.isArray(data?.rows) || !data?.rows.length || infos.isNil) {
+      return [];
+    }
+    return data.rows;
+  }, [data, infos]);
+  return [parsedData, { meta: data?.meta, isLoading }];
 };
 var MaintenanceStatus = /* @__PURE__ */ ((MaintenanceStatus2) => {
   MaintenanceStatus2[MaintenanceStatus2["None"] = 0] = "None";
@@ -6372,7 +7020,7 @@ function useMaintenanceStatus() {
   const [startTime, setStartTime] = React.useState();
   const [endTime, setEndTime] = React.useState();
   const [brokerName, setBrokerName] = React.useState("Orderly network");
-  const { data: systemInfo, mutate: mutate3 } = useQuery(
+  const { data: systemInfo, mutate: mutate5 } = useQuery(
     `/v1/public/system_info?source=maintenance`,
     {
       revalidateOnFocus: false,
@@ -6432,23 +7080,30 @@ var useStorageLedgerAddress = () => {
     ledgerWallet
   };
 };
+
+// src/orderly/usePrivateDataObserver.ts
 var usePrivateDataObserver = (options) => {
   const ws = useWS();
   const ee = useEventEmitter();
-  const { state, account: account5 } = useAccount();
+  const { state, account: account7 } = useAccount();
   const { setAccountInfo, restoreHolding, cleanAll } = useAppStore(
     (state2) => state2.actions
   );
   const statusActions = useApiStatusActions();
   const calculatorService = useCalculatorService();
   const positionsActions = usePositionActions();
-  const { data: clientInfo } = usePrivateQuery("/v1/client/info");
+  const { data: clientInfo } = usePrivateQuery(
+    "/v1/client/info",
+    {
+      revalidateOnFocus: false
+    }
+  );
   React.useEffect(() => {
     if (clientInfo) {
       setAccountInfo(clientInfo);
     }
   }, [clientInfo, setAccountInfo]);
-  const { data: positions2, isLoading: isPositionLoading } = usePrivateQuery("/v1/positions", {
+  const { data: positions3, isLoading: isPositionLoading } = usePrivateQuery("/v1/positions", {
     formatter: (data) => data,
     onError: (error) => {
       statusActions.updateApiError("positions", error.message);
@@ -6463,9 +7118,9 @@ var usePrivateDataObserver = (options) => {
         positionsActions.clearAll();
       }
     };
-    account5.on(core.EVENT_NAMES.statusChanged, handler);
+    account7.on(core.EVENT_NAMES.statusChanged, handler);
     return () => {
-      account5.off(core.EVENT_NAMES.statusChanged, handler);
+      account7.off(core.EVENT_NAMES.statusChanged, handler);
     };
   }, []);
   React.useEffect(() => {
@@ -6474,10 +7129,10 @@ var usePrivateDataObserver = (options) => {
     }
   }, [isPositionLoading, statusActions]);
   React.useEffect(() => {
-    if (positions2 && Array.isArray(positions2.rows)) {
-      calculatorService.calc("position" /* POSITION */, positions2);
+    if (positions3 && Array.isArray(positions3.rows)) {
+      calculatorService.calc("position" /* POSITION */, positions3);
     }
-  }, [calculatorService, positions2]);
+  }, [calculatorService, positions3]);
   const { data: holding } = usePrivateQuery(
     "/v1/client/holding",
     {
@@ -6486,6 +7141,8 @@ var usePrivateDataObserver = (options) => {
     }
   );
   React.useEffect(() => {
+    if (!account7.accountId)
+      return;
     const unsubscribe = ws.privateSubscribe(
       {
         id: "balance",
@@ -6502,20 +7159,32 @@ var usePrivateDataObserver = (options) => {
         }
       }
     );
-    return () => unsubscribe();
-  }, []);
+    return () => unsubscribe?.();
+  }, [account7.accountId]);
+  const isHoldingInit = React.useRef(false);
   React.useEffect(() => {
-    if (holding) {
+    if (!holding) {
+      return;
+    }
+    if (isHoldingInit.current) {
+      calculatorService.calc("portfolio" /* PORTFOLIO */, { holding });
+    } else {
       restoreHolding(holding);
     }
+    isHoldingInit.current = true;
   }, [holding]);
-  const [subOrder, setSubOrder] = useLocalStorage(
-    "orderly_subscribe_order",
-    true
-  );
+  const [subOrder] = useLocalStorage("orderly_subscribe_order", true);
   const updateOrders = (data, isAlgoOrder) => {
     const keysMap = options.getKeysMap("orders");
-    keysMap.forEach((getKey, key) => {
+    const filteredKeys = /* @__PURE__ */ new Map();
+    const keyStartWith = isAlgoOrder ? "algoOrders" : "orders";
+    const keys = keysMap.keys();
+    for (const key of keys) {
+      if (key.startsWith(keyStartWith)) {
+        filteredKeys.set(key, keysMap.get(key));
+      }
+    }
+    filteredKeys.forEach((getKey, key) => {
       useSWR.mutate(
         useSWRInfinite.unstable_serialize((index, prevData) => [
           getKey(index, prevData),
@@ -6548,10 +7217,12 @@ var usePrivateDataObserver = (options) => {
     });
   };
   React.useEffect(() => {
-    if (!state.accountId)
+    if (!state.accountId) {
       return;
-    if (subOrder !== true)
+    }
+    if (subOrder !== true) {
       return;
+    }
     const unsubscribe = ws.privateSubscribe("executionreport", {
       onMessage: (data) => {
         updateOrders(data, false);
@@ -6572,8 +7243,9 @@ var usePrivateDataObserver = (options) => {
     return () => unsubscribe?.();
   }, [state.accountId, subOrder]);
   React.useEffect(() => {
-    if (!state.accountId)
+    if (!state.accountId) {
       return;
+    }
     const key = ["/v1/positions", state.accountId];
     const unsubscribe = ws.privateSubscribe("position", {
       onMessage: (data) => {
@@ -6602,9 +7274,7 @@ var usePrivateDataObserver = (options) => {
               if (nextPositions.length > 0) {
                 newPositions.rows = [
                   ...newPositions.rows,
-                  ...nextPositions.map((item) => {
-                    return object2underscore(item);
-                  })
+                  ...nextPositions.map(object2underscore)
                 ];
               }
               return newPositions;
@@ -6621,43 +7291,6 @@ var usePrivateDataObserver = (options) => {
     };
   }, [state.accountId]);
 };
-var useWSObserver = (calculatorService) => {
-  const ws = useWS();
-  React.useEffect(() => {
-    const markPriceSubscription = ws.subscribe("markprices", {
-      onMessage: (message) => {
-        const data = /* @__PURE__ */ Object.create(null);
-        for (let index = 0; index < message.length; index++) {
-          const element = message[index];
-          data[element.symbol] = element.price;
-        }
-        calculatorService.calc("markPrice" /* MARK_PRICE */, data, {
-          skipWhenOnPause: true
-        });
-      },
-      onError: (error) => {
-      }
-    });
-    const indexPriceSubscription = ws.subscribe("indexprices", {
-      onMessage: (message) => {
-        if (!Array.isArray(message))
-          return;
-        const prices = /* @__PURE__ */ Object.create(null);
-        for (let index = 0; index < message.length; index++) {
-          const element = message[index];
-          prices[element.symbol.replace("SPOT", "PERP")] = element.price;
-        }
-        calculatorService.calc("indexPrice" /* INDEX_PRICE */, prices, {
-          skipWhenOnPause: true
-        });
-      }
-    });
-    return () => {
-      markPriceSubscription?.();
-      indexPriceSubscription?.();
-    };
-  }, []);
-};
 var useMarketStore = zustand.create(
   (set, get3) => ({
     market: [],
@@ -6763,7 +7396,9 @@ var DataCenterContext = React.createContext(
   {}
 );
 var useDataCenterContext = () => React.useContext(DataCenterContext);
-var DataCenterProvider = ({ children }) => {
+var DataCenterProvider = ({
+  children
+}) => {
   const { error, done } = usePreLoadData();
   const calculatorService = useCalculatorService();
   usePublicDataObserver();
@@ -6777,8 +7412,9 @@ var DataCenterProvider = ({ children }) => {
   if (error) {
     return /* @__PURE__ */ jsxRuntime.jsx("div", { children: "Data load failed" });
   }
-  if (!done)
+  if (!done) {
     return null;
+  }
   return /* @__PURE__ */ jsxRuntime.jsx(
     DataCenterContext.Provider,
     {
@@ -6860,7 +7496,7 @@ var ExtendedConfigStore = class extends core.DefaultConfigStore {
   }
 };
 var OrderlyConfigProvider = (props) => {
-  const [account5, setAccount] = React__default.default.useState(null);
+  const [account7, setAccount] = React__default.default.useState(null);
   const {
     configStore,
     keyStore,
@@ -6898,9 +7534,9 @@ var OrderlyConfigProvider = (props) => {
     ];
   }, [walletAdapters]);
   React.useLayoutEffect(() => {
-    let account6 = core.SimpleDI.get(core.Account.instanceName);
-    if (!account6) {
-      account6 = new core.Account(
+    let account8 = core.SimpleDI.get(core.Account.instanceName);
+    if (!account8) {
+      account8 = new core.Account(
         innerConfigStore,
         innerKeyStore,
         // innerGetWalletAdapter,
@@ -6909,9 +7545,9 @@ var OrderlyConfigProvider = (props) => {
           contracts
         }
       );
-      core.SimpleDI.registerByName(core.Account.instanceName, account6);
+      core.SimpleDI.registerByName(core.Account.instanceName, account8);
     }
-    setAccount(account6);
+    setAccount(account8);
   }, []);
   const filteredChains = React.useMemo(() => {
     if (typeof chainFilter === "function") {
@@ -6919,7 +7555,7 @@ var OrderlyConfigProvider = (props) => {
     }
     return chainFilter;
   }, [props.chainFilter, innerConfigStore]);
-  if (!account5) {
+  if (!account7) {
     return null;
   }
   return /* @__PURE__ */ jsxRuntime.jsx(
@@ -7176,6 +7812,16 @@ function formatNumber(qty, dp) {
     return void 0;
   }
 }
+function calculate(values2, fieldName, value, markPrice, config) {
+  const fieldHandler = getCalculateHandler(fieldName);
+  const newValues = ramda.compose(
+    ramda.head,
+    // orderEntityFormatHandle(baseDP, quoteDP),
+    fieldHandler,
+    baseInputHandle
+  )([values2, fieldName, value, markPrice, config]);
+  return newValues;
+}
 function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
   let isNewVersion = false;
   if (typeof symbolOrOrder === "object") {
@@ -7195,7 +7841,7 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
   const notSupportData = React.useRef({});
   const [errors, setErrors] = React.useState(null);
   const ee = useEventEmitter();
-  const positions2 = usePositions();
+  const positions3 = usePositions();
   const fieldDirty = React.useRef({});
   const submitted = React.useRef(false);
   const askAndBid = React.useRef([]);
@@ -7418,7 +8064,7 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
     }
     return createOrder(parsedData);
   }, [parsedData]);
-  const calculate = React.useCallback(
+  const calculate2 = React.useCallback(
     (values2, field, value) => {
       const fieldHandler = getCalculateHandler(field);
       const newValues = ramda.compose(
@@ -7468,7 +8114,7 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
     if (typeof parsedData.order_quantity !== "undefined") {
       fieldDirty.current.order_quantity = true;
     }
-    const values2 = calculate(parsedData, item.key, item.value);
+    const values2 = calculate2(parsedData, item.key, item.value);
     values2.isStopOrder = values2.order_type?.startsWith("STOP") || false;
     values2.total = values2.total || "";
     prevOrderData.current = parsedData;
@@ -7569,7 +8215,7 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
       baseIMR,
       baseMMR,
       totalCollateral,
-      positions: positions2 == null ? [] : positions2,
+      positions: positions3 == null ? [] : positions3,
       IMR_Factor: accountInfo["imr_factor"][symbol],
       orderFee,
       newOrder: {
@@ -7600,7 +8246,7 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
       return null;
     const leverage = perp.order.estLeverage({
       totalCollateral,
-      positions: positions2 === null ? [] : positions2,
+      positions: positions3 === null ? [] : positions3,
       newOrder: {
         symbol: parsedData.symbol,
         qty: result.quantity,
@@ -7612,7 +8258,7 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
     baseIMR,
     baseMMR,
     totalCollateral,
-    positions2,
+    positions3,
     formattedOrder?.order_price,
     formattedOrder?.order_quantity,
     formattedOrder?.total,
@@ -7631,7 +8277,7 @@ function useOrderEntry(symbolOrOrder, sideOrOptions, reduceOnly, options) {
     estLeverage,
     helper: {
       //@ts-ignore
-      calculate,
+      calculate: calculate2,
       validator
       // clearErrors,
     },
@@ -8466,12 +9112,12 @@ var useDaily = (options) => {
     start_date,
     end_date
   )}`;
-  const { data: dailyVolume, mutate: mutate3 } = usePrivateQuery(url, {
+  const { data: dailyVolume, mutate: mutate5 } = usePrivateQuery(url, {
     revalidateOnFocus: true
   });
   return {
     data: dailyVolume,
-    mutate: mutate3
+    mutate: mutate5
   };
 };
 var useReferralRebateSummary = (params) => {
@@ -8583,14 +9229,14 @@ var useRefereeRebateSummary = (params) => {
   }
   const {
     data,
-    mutate: mutate3,
+    mutate: mutate5,
     isLoading
   } = usePrivateQuery(url, {
     revalidateOnFocus: true
   });
   return {
     data,
-    mutate: mutate3,
+    mutate: mutate5,
     isLoading
   };
 };
@@ -8639,12 +9285,9 @@ var useGetReferralCode = (accountId) => {
   };
 };
 var useReferralInfo = () => {
-  const {
-    data,
-    mutate: mutate3,
-    isLoading,
-    error
-  } = usePrivateQuery("/v1/referral/info", {
+  const { state } = useAccount();
+  const { data, isLoading, error } = useSubAccountQuery("/v1/referral/info", {
+    accountId: state?.mainAccountId,
     revalidateOnFocus: true
   });
   const isTrader = React.useMemo(() => {
@@ -8657,7 +9300,10 @@ var useReferralInfo = () => {
       return void 0;
     return (data?.referrer_info?.referral_codes?.length || 0) > 0;
   }, [data?.referrer_info]);
-  const [pinCodes] = useLocalStorage("orderly_referral_codes", []);
+  const [pinCodes] = useLocalStorage(
+    "orderly_referral_codes",
+    []
+  );
   const getFirstRefCode = React.useCallback(() => {
     if (!data?.referrer_info.referral_codes)
       return void 0;
@@ -8748,9 +9394,9 @@ var useAllBrokers = () => {
 };
 var useCurEpochEstimate = (type) => {
   const [data, setData] = React.useState(void 0);
-  const { account: account5 } = useAccount();
+  const { account: account7 } = useAccount();
   const brokers = useAllBrokers();
-  const address = account5.address;
+  const address = account7.address;
   const path2 = type === "normal" /* normal */ ? `/v1/public/trading_rewards/current_epoch_estimate?address=${address}` : `/v1/public/market_making_rewards/current_epoch_estimate?address=${address}`;
   const { data: estimateData } = useQuery(address !== void 0 ? path2 : "", {
     formatter: (res) => {
@@ -13710,14 +14356,14 @@ var DistributionId = /* @__PURE__ */ ((DistributionId2) => {
 })(DistributionId || {});
 var useGetClaimed = (id) => {
   const [data, setData] = React.useState(0);
-  const { account: account5 } = useAccount();
-  const address = account5.address;
+  const { account: account7 } = useAccount();
+  const address = account7.address;
   const env = useGetEnv();
   const refresh = React.useCallback(() => {
     const params = getContractByEnv(env);
     if (typeof address === "undefined")
       return;
-    account5.walletAdapter?.callOnChain(
+    account7.walletAdapter?.callOnChain(
       // @ts-ignore
       { public_rpc_url: params.orderlyChainRpcUrl },
       params.orderlyContract,
@@ -13742,8 +14388,8 @@ var useGetClaimed = (id) => {
 
 // src/trading-rewards/useWalletRewardsHistory.ts
 var useWalletRewardsHistory = (type) => {
-  const { account: account5 } = useAccount();
-  const address = account5.address;
+  const { account: account7 } = useAccount();
+  const address = account7.address;
   const path2 = type === "normal" /* normal */ ? `/v1/public/trading_rewards/wallet_rewards_history?address=${address}` : `/v1/public/market_making_rewards/group_rewards_history?address=${address}`;
   const {
     data,
@@ -13765,11 +14411,36 @@ var useWalletRewardsHistory = (type) => {
   });
   return [data, { refresh, error }];
 };
+
+// src/trading-rewards/useTradingRwardsStatus.tsx
+var EpochStatus = /* @__PURE__ */ ((EpochStatus2) => {
+  EpochStatus2["active"] = "Active";
+  EpochStatus2["paused"] = "Paused";
+  EpochStatus2["ended"] = "Ended";
+  return EpochStatus2;
+})(EpochStatus || {});
+function useTradingRewardsStatus(isMMRewards) {
+  const path2 = isMMRewards ? "/v1/public/market_making_rewards/status" : "/v1/public/trading_rewards/status";
+  const { data: statusInfo } = useQuery(path2, {
+    formatter: (res) => {
+      const data = {
+        ...res,
+        epochStatus: res.epoch_status,
+        currentEpoch: res.current_epoch,
+        lastCompletedEpoch: res.last_completed_epoch
+      };
+      return data;
+    }
+  });
+  return {
+    statusInfo
+  };
+}
 var useApiKeyManager = (queryParams) => {
-  const { account: account5 } = useAccount();
+  const { account: account7, state, isSubAccount } = useAccount();
   const { keyInfo } = queryParams || {};
   const keyInfoPrams = getQueryParamsFromObject(keyInfo);
-  const { data, mutate: mutate3, error, isLoading } = usePrivateQuery(
+  const { data, mutate: mutate5, error, isLoading } = usePrivateQuery(
     `/v1/client/key_info${keyInfoPrams.length > 0 ? `?${keyInfoPrams}` : ""}`,
     {
       formatter: (data2) => data2?.rows
@@ -13802,7 +14473,14 @@ var useApiKeyManager = (queryParams) => {
     });
   }, []);
   const generateOrderlyKey = (scope) => {
-    return account5?.createApiKey(365, {
+    if (isSubAccount) {
+      return account7?.createSubAccountApiKey(365, {
+        tag: "manualCreated",
+        scope,
+        subAccountId: state.accountId
+      });
+    }
+    return account7?.createApiKey(365, {
       tag: "manualCreated",
       scope
     });
@@ -13816,7 +14494,7 @@ var useApiKeyManager = (queryParams) => {
   return [
     data,
     {
-      refresh: mutate3,
+      refresh: mutate5,
       error,
       isLoading,
       generateOrderlyKey,
@@ -13927,7 +14605,7 @@ var calcEstLiqPrice = (order, askAndBid, inputs) => {
     markPrice,
     totalCollateral,
     futures_taker_fee_rate,
-    positions: positions2
+    positions: positions3
   } = inputs;
   const orderFee = perp.order.orderFee({
     qty: quantity,
@@ -13939,7 +14617,7 @@ var calcEstLiqPrice = (order, askAndBid, inputs) => {
     baseIMR,
     baseMMR,
     totalCollateral,
-    positions: positions2 == null ? [] : positions2,
+    positions: positions3 == null ? [] : positions3,
     IMR_Factor: imr_factor,
     orderFee,
     newOrder: {
@@ -13954,7 +14632,7 @@ var calcEstLiqPrice = (order, askAndBid, inputs) => {
 };
 var calcEstLeverage = (order, askAndBid, inputs) => {
   const result = getPriceAndQty(order, askAndBid);
-  const { totalCollateral, positions: positions2, symbol } = inputs;
+  const { totalCollateral, positions: positions3, symbol } = inputs;
   if (!result)
     return null;
   const { price, quantity } = result;
@@ -13962,7 +14640,7 @@ var calcEstLeverage = (order, askAndBid, inputs) => {
     return null;
   return perp.order.estLeverage({
     totalCollateral,
-    positions: positions2,
+    positions: positions3,
     newOrder: {
       symbol,
       qty: result.quantity,
@@ -14056,7 +14734,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
     ...options.initialOrder
   };
   const { actions: orderEntryActions, entry: orderEntity } = useOrderStore(initialOrder);
-  const calculate = React.useCallback(
+  const calculate2 = React.useCallback(
     (values2, fieldName, value, markPrice, config) => {
       const fieldHandler = getCalculateHandler(fieldName);
       const newValues = ramda.compose(
@@ -14078,7 +14756,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
       return;
     }
     const { markPrice } = additional ?? { markPrice: 0 };
-    let newValues = calculate(
+    let newValues = calculate2(
       { ...orderEntity },
       key,
       value,
@@ -14087,7 +14765,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
     );
     if (key === "order_type") {
       if (value === types.OrderType.MARKET || value === types.OrderType.STOP_MARKET) {
-        newValues = calculate(
+        newValues = calculate2(
           newValues,
           "order_price",
           markPrice,
@@ -14121,7 +14799,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
   const calculateTPSL = (key, newValues, markPrice, symbolInfo2) => {
     if (key === "order_price") {
       if (typeof newValues.tp_pnl !== "undefined") {
-        newValues = calculate(
+        newValues = calculate2(
           newValues,
           "tp_pnl",
           newValues.tp_pnl,
@@ -14130,7 +14808,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
         );
       }
       if (typeof newValues.sl_pnl !== "undefined") {
-        newValues = calculate(
+        newValues = calculate2(
           newValues,
           "sl_pnl",
           newValues.sl_pnl,
@@ -14140,7 +14818,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
       }
     } else {
       if (typeof newValues.tp_trigger_price !== "undefined") {
-        newValues = calculate(
+        newValues = calculate2(
           newValues,
           "tp_trigger_price",
           newValues.tp_trigger_price,
@@ -14149,7 +14827,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
         );
       }
       if (typeof newValues.sl_trigger_price !== "undefined") {
-        newValues = calculate(
+        newValues = calculate2(
           newValues,
           "sl_trigger_price",
           newValues.sl_trigger_price,
@@ -14167,7 +14845,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
     }
     let newValues = { ...orderEntity };
     Object.keys(values2).forEach((key) => {
-      newValues = calculate(
+      newValues = calculate2(
         newValues,
         key,
         values2[key],
@@ -14184,7 +14862,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
         return;
       let newValues = { ...orderEntity };
       if (baseOn.length === 0) {
-        newValues = calculate(
+        newValues = calculate2(
           { ...orderEntity },
           "order_price",
           markPrice,
@@ -14193,7 +14871,7 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
         );
       } else {
         baseOn.forEach((key) => {
-          newValues = calculate(
+          newValues = calculate2(
             { ...newValues },
             key,
             orderEntity[key],
@@ -14220,14 +14898,15 @@ var useOrderEntryNextInternal = (symbol, options = {}) => {
       }
       orderEntryActions.updateOrder(newValues);
     },
-    [calculate, options.symbolInfo, orderEntity, orderEntryActions]
+    [calculate2, options.symbolInfo, orderEntity, orderEntryActions]
   );
   const validate = (order, creator, options2) => {
-    const { markPrice, maxQty } = options2;
+    const { markPrice, maxQty, estSlippage } = options2;
     return creator?.validate(order, {
       symbol: symbolInfo,
       maxQty,
-      markPrice
+      markPrice,
+      estSlippage
     });
   };
   const generateOrder = (creator, options2) => {
@@ -14278,7 +14957,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
   const actions = useMarkPriceActions();
   const symbolConfig = useSymbolsInfo();
   const accountInfo = useAccountInfo();
-  const positions2 = usePositions();
+  const positions3 = usePositions();
   const symbolInfo = symbolConfig[symbol]();
   const markPrice = actions.getMarkPriceBySymbol(symbol);
   const {
@@ -14294,6 +14973,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
     ...options,
     symbolInfo
   });
+  const [estSlippage, setEstSlippage] = React.useState(null);
   const [doCreateOrder, { isMutating }] = useMutation(
     getCreateOrderUrl(formattedOrder)
   );
@@ -14327,12 +15007,61 @@ var useOrderEntry2 = (symbol, options = {}) => {
       updateOrderPrice();
     }
   };
+  const updateEstSlippage = (orderBook) => {
+    if (formattedOrder.order_type !== types.OrderType.MARKET || !formattedOrder.order_quantity) {
+      setEstSlippage(null);
+      return;
+    }
+    const { order_quantity, side } = formattedOrder;
+    let avgExecutionPrice;
+    let book;
+    const filledBorders = [];
+    let orderQuantity = new utils.Decimal(order_quantity);
+    if (side === types.OrderSide.BUY) {
+      book = orderBook.asks.reverse();
+    } else {
+      book = orderBook.bids;
+    }
+    for (let i = 0; i < book.length; i++) {
+      const price = book[i][0];
+      const quantity = book[i][1];
+      if (isNaN(price) || isNaN(quantity)) {
+        continue;
+      }
+      if (orderQuantity.gt(quantity)) {
+        orderQuantity = orderQuantity.minus(quantity);
+        filledBorders.push([price, quantity]);
+      } else {
+        filledBorders.push([price, orderQuantity.toNumber()]);
+        break;
+      }
+    }
+    if (filledBorders.length > 0) {
+      const sumPrice = filledBorders.reduce((acc, curr) => {
+        return acc.plus(new utils.Decimal(curr[0]).mul(curr[1]));
+      }, utils.zero);
+      avgExecutionPrice = sumPrice.div(order_quantity);
+    }
+    if (avgExecutionPrice) {
+      const bestPrice = book[0][0];
+      const estSlippage2 = avgExecutionPrice.minus(bestPrice).abs().div(bestPrice).toNumber();
+      setEstSlippage(estSlippage2);
+    }
+  };
   React.useEffect(() => {
     updateOrderPrice();
   }, [formattedOrder.order_type_ext, formattedOrder.level]);
   const onOrderBookUpdate = useDebounce.useDebouncedCallback((data) => {
-    askAndBid.current = data;
+    const parsedData = [
+      [data.asks?.[data.asks.length - 1]?.[0], data.bids?.[0]?.[0]],
+      [data.asks?.[data.asks.length - 2]?.[0], data.bids?.[1]?.[0]],
+      [data.asks?.[data.asks.length - 3]?.[0], data.bids?.[2]?.[0]],
+      [data.asks?.[data.asks.length - 4]?.[0], data.bids?.[3]?.[0]],
+      [data.asks?.[data.asks.length - 5]?.[0], data.bids?.[4]?.[0]]
+    ];
+    askAndBid.current = parsedData;
     updateOrderPriceByOrderBook();
+    updateEstSlippage(data);
   }, 200);
   React.useEffect(() => {
     ee.on("orderbook:update", onOrderBookUpdate);
@@ -14358,9 +15087,10 @@ var useOrderEntry2 = (symbol, options = {}) => {
   const prepareData = React.useCallback(() => {
     return {
       markPrice: actions.getMarkPriceBySymbol(symbol),
-      maxQty
+      maxQty,
+      estSlippage
     };
-  }, [maxQty, symbol]);
+  }, [maxQty, symbol, estSlippage]);
   const interactiveValidate = (order) => {
     validateFunc(order).then((errors) => {
       const keys = Object.keys(errors);
@@ -14472,10 +15202,10 @@ var useOrderEntry2 = (symbol, options = {}) => {
       futures_taker_fee_rate: accountInfo.futures_taker_fee_rate,
       imr_factor: accountInfo.imr_factor[symbol],
       symbol,
-      positions: positions2
+      positions: positions3
     });
     return estLiqPrice2;
-  }, [formattedOrder, accountInfo, positions2, totalCollateral, symbol, maxQty]);
+  }, [formattedOrder, accountInfo, positions3, totalCollateral, symbol, maxQty]);
   const estLeverage = React.useMemo(() => {
     const orderQuantity = Number(formattedOrder.order_quantity);
     if (orderQuantity === 0 || orderQuantity > maxQty) {
@@ -14483,10 +15213,10 @@ var useOrderEntry2 = (symbol, options = {}) => {
     }
     return calcEstLeverage(formattedOrder, askAndBid.current[0], {
       totalCollateral,
-      positions: positions2,
+      positions: positions3,
       symbol
     });
-  }, [formattedOrder, accountInfo, positions2, totalCollateral, symbol, maxQty]);
+  }, [formattedOrder, accountInfo, positions3, totalCollateral, symbol, maxQty]);
   const resetErrors = () => {
     setMeta(
       immer$1.produce((draft) => {
@@ -14548,6 +15278,7 @@ var useOrderEntry2 = (symbol, options = {}) => {
     maxQty,
     estLiqPrice,
     estLeverage,
+    estSlippage,
     helper: {
       /**
        * @deprecated use validate instead
@@ -14778,14 +15509,104 @@ var useRestrictedInfo = (options) => {
     content
   };
 };
+var usePositionClose = (options) => {
+  const { position, order: initialOrder } = options;
+  const { type, quantity, price } = initialOrder;
+  const symbol = position.symbol;
+  const [errors, setErrors] = React.useState(null);
+  const symbolsInfo = useSymbolsInfo();
+  const { data: markPrices } = useMarkPricesStream();
+  const [doCreateOrder, { isMutating }] = useSubAccountMutation(
+    "/v1/order",
+    "POST",
+    {
+      accountId: position.account_id
+    }
+  );
+  const side = position.position_qty > 0 ? types.OrderSide.SELL : types.OrderSide.BUY;
+  const closeOrderData = React.useMemo(() => {
+    const data = {
+      order_quantity: quantity,
+      symbol,
+      order_type: type,
+      side,
+      reduce_only: true
+    };
+    if (type === types.OrderType.LIMIT) {
+      data.order_price = price;
+    }
+    return data;
+  }, [symbol, price, type, quantity]);
+  const maxQty = React.useMemo(() => {
+    if (!position) {
+      return 0;
+    }
+    const positionQty = position.position_qty;
+    if (positionQty > 0) {
+      if (side === types.OrderSide.BUY) {
+        return 0;
+      } else {
+        return Math.abs(positionQty);
+      }
+    }
+    if (positionQty < 0) {
+      if (side === types.OrderSide.BUY) {
+        return Math.abs(positionQty);
+      } else {
+        return 0;
+      }
+    }
+    return 0;
+  }, [position, side]);
+  const validate = React.useCallback(
+    async (data) => {
+      const creator = getOrderCreator(data);
+      const errors2 = await creator.validate(data, {
+        symbol: symbolsInfo[symbol](),
+        maxQty,
+        markPrice: markPrices[symbol]
+      });
+      return errors2;
+    },
+    [markPrices, maxQty, symbol, symbolsInfo]
+  );
+  React.useEffect(() => {
+    validate(closeOrderData).then((errors2) => {
+      setErrors(errors2);
+    });
+  }, [validate, closeOrderData]);
+  const submit = React.useCallback(async () => {
+    const errors2 = await validate(closeOrderData);
+    if (Object.keys(errors2).length > 0) {
+      throw errors2;
+    }
+    return doCreateOrder(closeOrderData).then((res) => {
+      if (res.success) {
+        return res;
+      }
+      throw res;
+    }).catch((err) => {
+      throw err;
+    });
+  }, [validate, doCreateOrder, closeOrderData]);
+  return {
+    submit,
+    isMutating,
+    side,
+    closeOrderData,
+    errors,
+    calculate
+  };
+};
 
+exports.swr = useSWR__namespace;
 Object.defineProperty(exports, "unstable_serialize", {
   enumerable: true,
   get: function () { return useSWR.unstable_serialize; }
 });
 Object.defineProperty(exports, "useSWR", {
   enumerable: true,
-  get: function () { return useSWR__default.default; }
+  get: function () { return useSWR__namespace.default; }
 });
 Object.defineProperty(exports, "useSWRConfig", {
   enumerable: true,
@@ -14799,6 +15620,7 @@ exports.AssetHistoryStatusEnum = AssetHistoryStatusEnum;
 exports.DefaultLayoutConfig = DefaultLayoutConfig;
 exports.DistributionId = DistributionId;
 exports.ENVType = ENVType2;
+exports.EpochStatus = EpochStatus;
 exports.ExtendedConfigStore = ExtendedConfigStore;
 exports.MaintenanceStatus = MaintenanceStatus;
 exports.MarketsStorageKey = MarketsStorageKey;
@@ -14813,6 +15635,7 @@ exports.WalletConnectorContext = WalletConnectorContext;
 exports.WsNetworkStatus = WsNetworkStatus;
 exports.checkNotional = checkNotional;
 exports.cleanStringStyle = cleanStringStyle;
+exports.fetcher = fetcher;
 exports.getMinNotional = getMinNotional;
 exports.parseJSON = parseJSON;
 exports.useAccount = useAccount;
@@ -14840,11 +15663,13 @@ exports.useFundingFeeHistory = useFundingFeeHistory;
 exports.useFundingRate = useFundingRate;
 exports.useFundingRateHistory = useFundingRateHistory;
 exports.useFundingRates = useFundingRates;
+exports.useFundingRatesStore = useFundingRatesStore;
 exports.useGetClaimed = useGetClaimed;
 exports.useGetEnv = useGetEnv;
 exports.useGetReferralCode = useGetReferralCode;
 exports.useHoldingStream = useHoldingStream;
 exports.useIndexPrice = useIndexPrice;
+exports.useIndexPricesStream = useIndexPricesStream;
 exports.useInfiniteQuery = useInfiniteQuery;
 exports.useKeyStore = useKeyStore;
 exports.useLazyQuery = useLazyQuery;
@@ -14871,6 +15696,7 @@ exports.useOrderStore = useOrderStore2;
 exports.useOrderStream = useOrderStream;
 exports.useOrderbookStream = useOrderbookStream;
 exports.usePositionActions = usePositionActions;
+exports.usePositionClose = usePositionClose;
 exports.usePositionStream = usePositionStream;
 exports.usePoster = usePoster;
 exports.usePreLoadData = usePreLoadData;
@@ -14890,13 +15716,21 @@ exports.useSimpleDI = useSimpleDI;
 exports.useStatisticsDaily = useStatisticsDaily;
 exports.useStorageChain = useStorageChain;
 exports.useStorageLedgerAddress = useStorageLedgerAddress;
+exports.useSubAccountDataObserver = useSubAccountDataObserver;
+exports.useSubAccountMutation = useSubAccountMutation;
+exports.useSubAccountQuery = useSubAccountQuery;
+exports.useSubAccountWS = useSubAccountWS;
 exports.useSymbolLeverage = useSymbolLeverage;
 exports.useSymbolPriceRange = useSymbolPriceRange;
 exports.useSymbolsInfo = useSymbolsInfo;
+exports.useSymbolsInfoStore = useSymbolsInfoStore;
 exports.useTPSLOrder = useTPSLOrder;
 exports.useTickerStream = useTickerStream;
 exports.useTrack = useTrack;
 exports.useTrackingInstance = useTrackingInstance;
+exports.useTradingRewardsStatus = useTradingRewardsStatus;
+exports.useTransfer = useTransfer;
+exports.useTransferHistory = useTransferHistory;
 exports.useWS = useWS;
 exports.useWalletConnector = useWalletConnector;
 exports.useWalletRewardsHistory = useWalletRewardsHistory;